Modelpublic

avsolatorio/all-MiniLM-L6-v2-MEDI-MTEB-triplet-randproj-trainableParams-GIST-512-latest

sourceHugging Faceapache-2.0updated 2y agoView on Hugging Face

0likes20downloads

Model Card

all-MiniLM-L6-v2 trained on MEDI-MTEB triplets

This is a sentence-transformers model finetuned from sentence-transformers/all-MiniLM-L6-v2 on the NQ, pubmed, spectertraintriples, S2ORCcitationsabstracts, fever, gooaqpairs, codesearchnet, wikihow, WikiAnswers, eli5questionanswer, amazon-qa, medmcqa, zeroshot, TriviaQApairs, PAQpairs, stackexchangeduplicatequestionstitle-bodytitle-body, trex, flickr30kcaptions, hotpotqa, task671ambigqatextgeneration, task061ropesanswergeneration, task285imdbanswergeneration, task905hatespeechoffensiveclassification, task566circaclassification, task184snlientailmenttoneutraltextmodification, task280stereosetclassificationstereotypetype, task1599smcalflowclassification, task1384dealornodialogclassification, task591sciqanswergeneration, task823peixian-rtgendersentimentanalysis, task023cosmosqaquestiongeneration, task900freebaseqacategoryclassification, task924event2mindwordgeneration, task152tomqafindlocationeasynoise, task1368healthfactsentencegeneration, task1661superglueclassification, task1187politifactclassification, task1728webnlgdatatotext, task112assetsimplesentenceidentification, task1340msrtextcompressioncompression, task072abductivenlianswergeneration, task1504hatexplainanswergeneration, task684onlineprivacypolicytextinformationtypegeneration, task1290xsumsummarization, task075squad1.1answergeneration, task1587scifactclassification, task384socialiqaquestionclassification, task1555scitailanswergeneration, task1532dailydialogemotionclassification, task239tweetqaanswergeneration, task596mochaquestiongeneration, task1411dartsubjectidentification, task1359numersenseanswergeneration, task329gapclassification, task220rocstoriestitleclassification, task316crows-pairsclassificationstereotype, task495semevalheadlineclassification, task1168browncoarsepostagging, task348squad2.0unanswerablequestiongeneration, task049multircquestionsneededtoanswer, task1534dailydialogquestionclassification, task322jigsawclassificationthreat, task295semeval2020task4commonsensereasoning, task186snlicontradictiontoentailmenttextmodification, task034winograndequestionmodificationobject, task160replaceletterinasentence, task469mrqaanswergeneration, task105storycloze-rocstoriessentencegeneration, task649raceblankquestiongeneration, task1536dailydialoghappinessclassification, task683onlineprivacypolicytextpurposeanswergeneration, task024cosmosqaanswergeneration, task584udepsengfinepostagging, task066timetravelbinaryconsistencyclassification, task413mickeyensentenceperturbationgeneration, task182duorcquestiongeneration, task028dropanswergeneration, task1601webquestionsanswergeneration, task1295adversarialqaquestionanswering, task201mnlineutralclassification, task038qasccombinedfact, task293storycommonsenseemotiontextgeneration, task572recipenlgtextgeneration, task517emoclassifyemotionofdialogue, task382hybridqaanswergeneration, task176breakdecomposequestions, task1291multinewssummarization, task155countnounsverbs, task031winograndequestiongenerationobject, task279stereosetclassificationstereotype, task1336peixianequityevaluationcorpusgenderclassifier, task508scruplesdilemmasmoreethicalisidentifiable, task518emodifferentdialogueemotions, task077splashexplanationtosql, task923event2mindclassifier, task470mrqaquestiongeneration, task638multiwozclassification, task1412webquestionsquestionanswering, task847pubmedqaquestiongeneration, task678ollieactualrelationshipanswergeneration, task290tellmewhyquestionanswerability, task575airdialogueclassification, task189snlineutraltocontradictiontextmodification, task026dropquestiongeneration, task162countwordsstartingwithletter, task079conalaconcatstrings, task610conllppner, task046miscellaneousquestiontyping, task197mnlidomainanswergeneration, task1325qazrequestiongenerationonsubjectrelation, task430sentevalsubjectcount, task672nummersense, task402grailqaparaphrasegeneration, task904hatespeechoffensiveclassification, task192hotpotqasentencegeneration, task069abductivenliclassification, task574airdialoguesentencegeneration, task187snlientailmenttocontradictiontextmodification, task749glucosereversecauseemotiondetection, task1552scitailquestiongeneration, task750aquamultiplechoiceanswering, task327jigsawclassificationtoxic, task1502hatexplainclassification, task328jigsawclassificationinsult, task304numericfusedheadresolution, task1293kilttaskshotpotqaquestionanswering, task216rocstoriescorrectanswergeneration, task1326qazrequestiongenerationfromanswer, task1338peixianequityevaluationcorpussentimentclassifier, task1729personachatgeneratenext, task1202atomicclassificationxneed, task400pawsparaphraseclassification, task502scruplesanecdoteswhoiswrongverification, task088identifytypoverification, task221rocstoriestwochoiceclassification, task200mnlientailmentclassification, task074squad1.1questiongeneration, task581socialiqaquestiongeneration, task1186nnehrngoclassification, task898freebaseqaanswergeneration, task1408dartsimilarityclassification, task168strategyqaquestiondecomposition, task1357xlsumsummarygeneration, task390torquetextspanselection, task165mcscriptquestionansweringcommonsense, task1533dailydialogformalclassification, task002quorefanswergeneration, task1297qascquestionanswering, task305jeopardyanswergenerationnormal, task029winograndefullobject, task1327qazreanswergenerationfromquestion, task326jigsawclassificationobscene, task1542everyithelementfromstarting, task570recipenlgnergeneration, task1409darttextgeneration, task401numericfusedheadreference, task846pubmedqaclassification, task1712pokiclassification, task344hybridqaanswergeneration, task875emotionclassification, task1214atomicclassificationxwant, task106scruplesethicaljudgment, task238iircanswerfrompassageanswergeneration, task1391winograndeeasyanswergeneration, task195sentiment140classification, task163countwordsendingwithletter, task579socialiqaclassification, task569recipenlgtextgeneration, task1602webquestionquestiongenreation, task747glucosecauseemotiondetection, task219rocstoriestitleanswergeneration, task178quartzquestionanswering, task103facts2storylongtextgeneration, task301recordquestiongeneration, task1369healthfactsentencegeneration, task515sentevaloddwordout, task496semevalanswergeneration, task1658billsumsummarization, task1204atomicclassificationhinderedby, task1392supergluemultircanswerverification, task306jeopardyanswergenerationdouble, task1286openbookqaquestionanswering, task159checkfrequencyofwordsinsentencepair, task151tomqafindlocationeasyclean, task323jigsawclassificationsexuallyexplicit, task037qascgeneraterelatedfact, task027dropanswertypegeneration, task1596event2mindtextgeneration2, task141odd-man-outclassificationcategory, task194duorcanswergeneration, task679hopeedienglishtextclassification, task246dreamquestiongeneration, task1195disflqadisfluenttofluentconversion, task065timetravelconsistentsentenceclassification, task351winomtclassificationgenderidentifiabilityanti, task580socialiqaanswergeneration, task583udepsengcoarsepostagging, task202mnlicontradictionclassification, task222rocstoriestwochioceslottingclassification, task498scruplesanecdoteswhoiswrongclassification, task067abductivenlianswergeneration, task616colaclassification, task286olidoffensejudgment, task188snlineutraltoentailmenttextmodification, task223quartzexplanationgeneration, task820protoqaanswergeneration, task196sentiment140answergeneration, task1678mathqaanswerselection, task349squad2.0answerableunanswerablequestionclassification, task154tomqafindlocationhardnoise, task333hateevalclassificationhateen, task235iircquestionfromsubtextanswergeneration, task1554scitailclassification, task210logic2textstructuredtextgeneration, task035winograndequestionmodificationperson, task230iircpassageclassification, task1356xlsumtitlegeneration, task1726mathqacorrectanswergeneration, task302recordclassification, task380boolqyesnoquestion, task212logic2textclassification, task748glucosereversecauseeventdetection, task834mathdatasetclassification, task350winomtclassificationgenderidentifiabilitypro, task191hotpotqaquestiongeneration, task236iircquestionfrompassageanswergeneration, task217rocstoriesorderinganswergeneration, task568circaquestiongeneration, task614glucosecauseeventdetection, task361spolinyesandpromptresponseclassification, task421persentsentencesentimentclassification, task203mnlisentencegeneration, task420persentdocumentsentimentclassification, task153tomqafindlocationhardclean, task346hybridqaclassification, task1211atomicclassificationhassubevent, task360spolinyesandresponsegeneration, task510reddittifutitlesummarization, task511reddittifulongtextsummarization, task345hybridqaanswergeneration, task270csrgcounterfactualcontextgeneration, task307jeopardyanswergenerationfinal, task001quorefquestiongeneration, task089swapwordsverification, task1196atomicclassificationoeffect, task080piqaanswergeneration, task1598nyclongtextgeneration, task240tweetqaquestiongeneration, task615moviesqaanswergeneration, task1347gluests-bsimilarityclassification, task114isthegivenwordlongest, task292storycommonsensecharactertextgeneration, task115helpadviceclassification, task431sentevalobjectcount, task1360numersensemultiplechoiceqageneration, task177para-nmtparaphrasing, task132daistextmodification, task269csrgcounterfactualstorygeneration, task233iirclinkexistsclassification, task161countwordscontainingletter, task1205atomicclassificationisafter, task571recipenlgnergeneration, task1292yelpreviewfulltextcategorization, task428sentevalinversion, task311racequestiongeneration, task429sentevaltense, task403creakcommonsenseinference, task929productsreviewsclassification, task582naturalquestionanswergeneration, task237iircanswerfromsubtextanswergeneration, task050multircanswerability, task184breakgeneratequestion, task669ambigqaanswergeneration, task169strategyqasentencegeneration, task500scruplesanecdotestitlegeneration, task241tweetqaclassification, task1345glueqqpquestionparaprashing, task218rocstoriesswaporderanswergeneration, task613politifacttextgeneration, task1167penntreebankcoarsepostagging, task1422mathqaphysics, task247dreamanswergeneration, task199mnliclassification, task164mcscriptquestionansweringtext, task1541agnewsclassification, task516sentevalconjointsinversion, task294storycommonsensemotivtextgeneration, task501scruplesanecdotesposttypeverification, task213rocstoriescorrectendingclassification, task821protoqaquestiongeneration, task493reviewpolarityclassification, task308jeopardyanswergenerationall, task1595event2mindtextgeneration1, task040qascquestiongeneration, task231iirclinkclassification, task1727wiqawhatistheeffect, task578curiositydialogsanswergeneration, task310raceclassification, task309raceanswergeneration, task379agnewstopicclassification, task030winograndefullperson, task1540parsedpdfssummarization, task039qascfindoverlappingwords, task1206atomicclassificationisbefore, task157countvowelsandconsonants, task339recordanswergeneration, task453swaganswergeneration, task848pubmedqaclassification, task673googlewellformedqueryclassification, task676ollierelationshipanswergeneration, task268caseholdlegalanswergeneration, task844financialphrasebankclassification, task330gapanswergeneration, task595mochaanswergeneration, task1285kpakeypointmatching, task234iircpassagelineanswergeneration, task494reviewpolarityanswergeneration, task670ambigqaquestiongeneration, task289gigawordsummarization, npr, nli, SimpleWiki, amazonreview2018, ccnewstitletext, agnews, xsum, msmarco, yahooanswerstitleanswer, squadpairs, wow, mteb-amazoncounterfactual-avstriplets, mteb-amazonmassiveintent-avstriplets, mteb-amazonmassivescenario-avstriplets, mteb-amazonreviewsmulti-avstriplets, mteb-banking77-avstriplets, mteb-emotion-avstriplets, mteb-imdb-avstriplets, mteb-mtopdomain-avstriplets, mteb-mtopintent-avstriplets, mteb-toxicconversations50k-avstriplets, mteb-tweetsentimentextraction-avstriplets and covid-bing-query-gpt4-avs_triplets datasets. It maps sentences & paragraphs to a 768-dimensional dense vector space and can be used for semantic textual similarity, semantic search, paraphrase mining, text classification, clustering, and more.

Model Details

Model Description

—Model Type: Sentence Transformer
—Base model: sentence-transformers/all-MiniLM-L6-v2
—Maximum Sequence Length: 256 tokens
—Output Dimensionality: 768 dimensions
—Similarity Function: Cosine Similarity
—Training Datasets:
—NQ
—pubmed
—spectertraintriples
—S2ORCcitationsabstracts
—fever
—gooaq_pairs
—codesearchnet
—wikihow
—WikiAnswers
—eli5questionanswer
—amazon-qa
—medmcqa
—zeroshot
—TriviaQA_pairs
—PAQ_pairs
—stackexchangeduplicatequestionstitle-bodytitle-body
—trex
—flickr30k_captions
—hotpotqa
—task671ambigqatext_generation
—task061ropesanswer_generation
—task285imdbanswer_generation
—task905hatespeechoffensiveclassification
—task566circaclassification
—task184snlientailmenttoneutraltextmodification
—task280stereosetclassificationstereotypetype
—task1599smcalflowclassification
—task1384dealornodialog_classification
—task591sciqanswer_generation
—task823peixian-rtgendersentiment_analysis
—task023cosmosqaquestion_generation
—task900freebaseqacategoryclassification
—task924event2mindword_generation
—task152tomqafindlocationeasy_noise
—task1368healthfactsentence_generation
—task1661superglue_classification
—task1187politifactclassification
—task1728webnlgdatato_text
—task112assetsimplesentenceidentification
—task1340msrtextcompressioncompression
—task072abductivenlianswer_generation
—task1504hatexplainanswer_generation
—task684onlineprivacypolicytextinformationtype_generation
—task1290xsumsummarization
—task075squad1.1answer_generation
—task1587scifactclassification
—task384socialiqaquestion_classification
—task1555scitailanswer_generation
—task1532dailydialogemotionclassification
—task239tweetqaanswer_generation
—task596mochaquestion_generation
—task1411dartsubject_identification
—task1359numersenseanswergeneration
—task329gapclassification
—task220rocstoriestitle_classification
—task316crows-pairsclassification_stereotype
—task495semevalheadline_classification
—task1168browncoarsepostagging
—task348squad2.0unanswerablequestiongeneration
—task049multircquestionsneededto_answer
—task1534dailydialogquestionclassification
—task322jigsawclassification_threat
—task295semeval2020task4commonsense_reasoning
—task186snlicontradictiontoentailmenttextmodification
—task034winograndequestionmodificationobject
—task160replaceletterina_sentence
—task469mrqaanswer_generation
—task105storycloze-rocstoriessentencegeneration
—task649raceblankquestiongeneration
—task1536dailydialoghappinessclassification
—task683onlineprivacypolicytextpurposeanswer_generation
—task024cosmosqaanswer_generation
—task584udepsengfinepos_tagging
—task066timetravelbinaryconsistencyclassification
—task413mickeyensentenceperturbation_generation
—task182duorcquestion_generation
—task028dropanswer_generation
—task1601webquestionsanswer_generation
—task1295adversarialqaquestionanswering
—task201mnlineutral_classification
—task038qasccombined_fact
—task293storycommonsenseemotiontextgeneration
—task572recipenlgtextgeneration
—task517emoclassifyemotionof_dialogue
—task382hybridqaanswer_generation
—task176breakdecompose_questions
—task1291multinews_summarization
—task155countnouns_verbs
—task031winograndequestiongenerationobject
—task279stereosetclassification_stereotype
—task1336peixianequityevaluationcorpusgenderclassifier
—task508scruplesdilemmasmoreethical_isidentifiable
—task518emodifferentdialogueemotions
—task077splashexplanationtosql
—task923event2mindclassifier
—task470mrqaquestion_generation
—task638multiwoz_classification
—task1412webquestionsquestionanswering
—task847pubmedqaquestion_generation
—task678ollieactualrelationshipanswer_generation
—task290tellmewhyquestion_answerability
—task575airdialogue_classification
—task189snlineutraltocontradictiontextmodification
—task026dropquestion_generation
—task162countwordsstartingwith_letter
—task079conalaconcat_strings
—task610conllppner
—task046miscellaneousquestion_typing
—task197mnlidomainanswergeneration
—task1325qazrequestiongenerationonsubject_relation
—task430sentevalsubject_count
—task672_nummersense
—task402grailqaparaphrase_generation
—task904hatespeechoffensiveclassification
—task192hotpotqasentence_generation
—task069abductivenliclassification
—task574airdialoguesentencegeneration
—task187snlientailmenttocontradictiontextmodification
—task749glucosereversecauseemotion_detection
—task1552scitailquestion_generation
—task750aquamultiplechoiceanswering
—task327jigsawclassification_toxic
—task1502hatexplainclassification
—task328jigsawclassification_insult
—task304numericfusedheadresolution
—task1293kilttaskshotpotqaquestion_answering
—task216rocstoriescorrectanswergeneration
—task1326qazrequestiongenerationfromanswer
—task1338peixianequityevaluationcorpussentimentclassifier
—task1729personachatgenerate_next
—task1202atomicclassification_xneed
—task400pawsparaphrase_classification
—task502scruplesanecdoteswhoiswrongverification
—task088identifytypo_verification
—task221rocstoriestwochoiceclassification
—task200mnlientailment_classification
—task074squad1.1question_generation
—task581socialiqaquestion_generation
—task1186nnehrngo_classification
—task898freebaseqaanswergeneration
—task1408dartsimilarity_classification
—task168strategyqaquestion_decomposition
—task1357xlsumsummary_generation
—task390torquetextspanselection
—task165mcscriptquestionansweringcommonsense
—task1533dailydialogformalclassification
—task002quorefanswer_generation
—task1297qascquestion_answering
—task305jeopardyanswergenerationnormal
—task029winograndefull_object
—task1327qazreanswergenerationfromquestion
—task326jigsawclassification_obscene
—task1542everyithelementfrom_starting
—task570recipenlgnergeneration
—task1409darttext_generation
—task401numericfusedheadreference
—task846pubmedqaclassification
—task1712pokiclassification
—task344hybridqaanswer_generation
—task875emotionclassification
—task1214atomicclassification_xwant
—task106scruplesethical_judgment
—task238iircanswerfrompassageanswergeneration
—task1391winograndeeasyanswergeneration
—task195sentiment140classification
—task163countwordsendingwith_letter
—task579socialiqaclassification
—task569recipenlgtextgeneration
—task1602webquestionquestion_genreation
—task747glucosecauseemotiondetection
—task219rocstoriestitleanswergeneration
—task178quartzquestion_answering
—task103facts2storylongtextgeneration
—task301recordquestion_generation
—task1369healthfactsentence_generation
—task515sentevaloddwordout
—task496semevalanswer_generation
—task1658billsumsummarization
—task1204atomicclassification_hinderedby
—task1392supergluemultircanswerverification
—task306jeopardyanswergenerationdouble
—task1286openbookqaquestion_answering
—task159checkfrequencyofwordsinsentence_pair
—task151tomqafindlocationeasy_clean
—task323jigsawclassificationsexuallyexplicit
—task037qascgeneraterelatedfact
—task027dropanswertypegeneration
—task1596event2mindtextgeneration2
—task141odd-man-outclassification_category
—task194duorcanswer_generation
—task679hopeedienglishtext_classification
—task246dreamquestion_generation
—task1195disflqadisfluenttofluent_conversion
—task065timetravelconsistentsentenceclassification
—task351winomtclassificationgenderidentifiability_anti
—task580socialiqaanswer_generation
—task583udepsengcoarsepos_tagging
—task202mnlicontradiction_classification
—task222rocstoriestwochioceslotting_classification
—task498scruplesanecdoteswhoiswrongclassification
—task067abductivenlianswer_generation
—task616colaclassification
—task286olidoffense_judgment
—task188snlineutraltoentailmenttextmodification
—task223quartzexplanation_generation
—task820protoqaanswer_generation
—task196sentiment140answer_generation
—task1678mathqaanswer_selection
—task349squad2.0answerableunanswerablequestion_classification
—task154tomqafindlocationhard_noise
—task333hateevalclassificationhateen
—task235iircquestionfromsubtextanswergeneration
—task1554scitailclassification
—task210logic2textstructuredtextgeneration
—task035winograndequestionmodificationperson
—task230iircpassage_classification
—task1356xlsumtitle_generation
—task1726mathqacorrectanswergeneration
—task302recordclassification
—task380boolqyesnoquestion
—task212logic2textclassification
—task748glucosereversecauseevent_detection
—task834mathdatasetclassification
—task350winomtclassificationgenderidentifiability_pro
—task191hotpotqaquestion_generation
—task236iircquestionfrompassageanswergeneration
—task217rocstoriesorderinganswergeneration
—task568circaquestion_generation
—task614glucosecauseeventdetection
—task361spolinyesandpromptresponse_classification
—task421persentsentencesentimentclassification
—task203mnlisentence_generation
—task420persentdocumentsentimentclassification
—task153tomqafindlocationhard_clean
—task346hybridqaclassification
—task1211atomicclassification_hassubevent
—task360spolinyesandresponsegeneration
—task510reddittifutitlesummarization
—task511reddittifulongtext_summarization
—task345hybridqaanswer_generation
—task270csrgcounterfactualcontextgeneration
—task307jeopardyanswergenerationfinal
—task001quorefquestion_generation
—task089swapwords_verification
—task1196atomicclassification_oeffect
—task080piqaanswer_generation
—task1598nyclongtextgeneration
—task240tweetqaquestion_generation
—task615moviesqaanswer_generation
—task1347gluests-bsimilarityclassification
—task114isthegivenword_longest
—task292storycommonsensecharactertextgeneration
—task115helpadvice_classification
—task431sentevalobject_count
—task1360numersensemultiplechoiceqageneration
—task177para-nmtparaphrasing
—task132daistext_modification
—task269csrgcounterfactualstorygeneration
—task233iirclinkexistsclassification
—task161countwordscontainingletter
—task1205atomicclassification_isafter
—task571recipenlgnergeneration
—task1292yelpreviewfulltext_categorization
—task428sentevalinversion
—task311racequestion_generation
—task429sentevaltense
—task403creakcommonsense_inference
—task929productsreviews_classification
—task582naturalquestionanswer_generation
—task237iircanswerfromsubtextanswergeneration
—task050multircanswerability
—task184breakgenerate_question
—task669ambigqaanswer_generation
—task169strategyqasentence_generation
—task500scruplesanecdotestitlegeneration
—task241tweetqaclassification
—task1345glueqqpquestionparaprashing
—task218rocstoriesswaporderanswer_generation
—task613politifacttext_generation
—task1167penntreebankcoarsepos_tagging
—task1422mathqaphysics
—task247dreamanswer_generation
—task199mnliclassification
—task164mcscriptquestionansweringtext
—task1541agnewsclassification
—task516sentevalconjoints_inversion
—task294storycommonsensemotivtextgeneration
—task501scruplesanecdotesposttype_verification
—task213rocstoriescorrectendingclassification
—task821protoqaquestion_generation
—task493reviewpolarity_classification
—task308jeopardyanswergenerationall
—task1595event2mindtextgeneration1
—task040qascquestion_generation
—task231iirclink_classification
—task1727wiqawhatisthe_effect
—task578curiositydialogsanswergeneration
—task310raceclassification
—task309raceanswer_generation
—task379agnewstopic_classification
—task030winograndefull_person
—task1540parsedpdfs_summarization
—task039qascfindoverlappingwords
—task1206atomicclassification_isbefore
—task157countvowelsandconsonants
—task339recordanswer_generation
—task453swaganswer_generation
—task848pubmedqaclassification
—task673googlewellformedqueryclassification
—task676ollierelationshipanswergeneration
—task268caseholdlegalanswergeneration
—task844financialphrasebank_classification
—task330gapanswer_generation
—task595mochaanswer_generation
—task1285kpakeypoint_matching
—task234iircpassagelineanswer_generation
—task494reviewpolarityanswergeneration
—task670ambigqaquestion_generation
—task289gigawordsummarization
—npr
—nli
—SimpleWiki
—amazonreview2018
—ccnewstitletext
—agnews
—xsum
—msmarco
—yahooanswerstitle_answer
—squad_pairs
—wow
—mteb-amazoncounterfactual-avstriplets
—mteb-amazonmassiveintent-avs_triplets
—mteb-amazonmassivescenario-avs_triplets
—mteb-amazonreviewsmulti-avs_triplets
—mteb-banking77-avs_triplets
—mteb-emotion-avs_triplets
—mteb-imdb-avs_triplets
—mteb-mtopdomain-avstriplets
—mteb-mtopintent-avstriplets
—mteb-toxicconversations50k-avs_triplets
—mteb-tweetsentimentextraction-avs_triplets
—covid-bing-query-gpt4-avs_triplets
—Language: en
—License: apache-2.0

Model Sources

—Documentation: Sentence Transformers Documentation
—Repository: Sentence Transformers on GitHub
—Hugging Face: Sentence Transformers on Hugging Face

Full Model Architecture

SentenceTransformer(
  (0): Transformer({'max_seq_length': 256, 'do_lower_case': False}) with Transformer model: BertModel 
  (1): RandomProjection({'in_features': 384, 'out_features': 768, 'seed': 42, 'requires_grad': True})
)

Usage

Direct Usage (Sentence Transformers)

First install the Sentence Transformers library:

bash

pip install -U sentence-transformers

Then you can load this model and run inference.

python

from sentence_transformers import SentenceTransformer

# Download from the 🤗 Hub
model = SentenceTransformer("avsolatorio/all-MiniLM-L6-v2-MEDI-MTEB-triplet-randproj-trainableParams-GIST-512-best")
# Run inference
sentences = [
    'Does living in an urban environment confer advantages for childhood nutritional status?',
    'The purpose of this paper is to examine the relationship between childhood undernutrition and poverty in urban and rural areas.Anthropometric and socio-economic data from Multiple Indicator Cluster Surveys in Angola-Secured Territory (Angola ST), Central African Republic and Senegal were used in this analysis. The population considered in this study is children 0-59 months, whose records include complete anthropometric data on height, weight, age, gender, socio-economic level and urban or rural area of residence. In addition to simple urban/rural comparisons, the population was stratified using a wealth index based on living conditions and asset ownership to compare the prevalence, mean Z-score and odds ratios for stunting and wasting.In all cases, when using a simple urban/rural comparison, the prevalence of stunting was significantly higher in rural areas. However, when the urban and rural populations were stratified using a measure of wealth, the differences in prevalence of stunting and underweight in urban and rural areas of Angola ST, Central African Republic and Senegal disappeared. Poor children in these urban areas were just as likely to be stunted or underweight as poor children living in rural areas. The odds ratio of stunting in the poorest compared with the richest quintile was 3.4, 3.2 and 1.5 in Angola ST, Senegal and Central African Republic, respectively.',
    'Increasing evidence exists that hyperprolactinemia alters metabolic profile. The mechanism of this effect is unknown. We aimed to investigate the differences between the metabolic profile of patients with prolactinomas and nonfunctional pituitary adenomas and to evaluate the impact of other pituitary hormones on their metabolic profile.Our retrospective study included 86 consecutive patients with prolactinomas and nonfunctional adenomas (29 prolactinomas and 57 adenomas). Body mass index (BMI), blood pressure, serum prolactin, growth hormone (GH), insulin-like growth factor I (IGF-I), adrenocorticotropic hormone (ACTH), cortisol, urinary free cortisol, triiodothyronine (T3), thyroxine (T4), thyroid-stimulating hormone (TSH), dehydroepiandrosterone-sulfate (DHEA-S), testosterone in men, triglycerides, total cholesterol, HDL (high-density lipoprotein) cholesterol, LDL (Low-density lipoprotein) cholesterol, alanine-transaminase, aspartate-transaminase, fasting glucose, and C-reactive protein (CRP) were obtained for all patients. Regression analyses were performed on log-transformed data.After adjustment for age, gender, and tumor size, prolactinomas were associated with higher BMI (OR 5.61, 95%CI 1.70-9.51, p = 0.005), LDL cholesterol (OR 3.60, 95%CI 1.35-5.93, p = 0.015), DHEA-S (OR 1.97, 95%CI 1.23-3.72, p = 0.026), and lower GH levels (OR 0.43, 95%CI 0.03-0.84, p = 0.037). In a linear multivariate regression, the association between DHEA-S, GH, and prolactin remained significant even after adjustment for BMI. GH and IGF-I were associated with BMI and LDL cholesterol, but the association diminished after adjustment for serum prolactin.',
]
embeddings = model.encode(sentences)
print(embeddings.shape)
# [3, 768]

# Get the similarity scores for the embeddings
similarities = model.similarity(embeddings, embeddings)
print(similarities.shape)
# [3, 3]

<!--

Direct Usage (Transformers)

<details><summary>Click to see the direct usage in Transformers</summary>

</details> -->

<!--

Downstream Usage (Sentence Transformers)

You can finetune this model on your own dataset.

<details><summary>Click to expand</summary>

</details> -->

<!--

Out-of-Scope Use

List how the model may foreseeably be misused and address what users ought not to do with the model. -->

Evaluation

Metrics

Triplet

—Dataset: medi-mteb-dev
—Evaluated with <code>TripletEvaluator</code>

Metric	Value
cosine_accuracy	0.8439

<!--

Bias, Risks and Limitations

What are the known or foreseeable issues stemming from this model? You could also flag here known failure cases or weaknesses of the model. -->

<!--

Recommendations

What are recommendations with respect to the foreseeable issues? For example, filtering explicit content. -->

Training Details

Training Datasets

NQ

—Dataset: NQ
—Size: 49,676 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 10 tokens</li><li>mean: 11.72 tokens</li><li>max: 28 tokens</li></ul> | <ul><li>min: 114 tokens</li><li>mean: 137.29 tokens</li><li>max: 211 tokens</li></ul> | <ul><li>min: 110 tokens</li><li>mean: 138.47 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

pubmed

—Dataset: pubmed
—Size: 29,908 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 6 tokens</li><li>mean: 22.76 tokens</li><li>max: 59 tokens</li></ul> | <ul><li>min: 82 tokens</li><li>mean: 239.84 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 48 tokens</li><li>mean: 239.63 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

spectertraintriples

—Dataset: spectertraintriples
—Size: 49,676 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:---------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 4 tokens</li><li>mean: 15.1 tokens</li><li>max: 53 tokens</li></ul> | <ul><li>min: 4 tokens</li><li>mean: 14.04 tokens</li><li>max: 43 tokens</li></ul> | <ul><li>min: 4 tokens</li><li>mean: 15.54 tokens</li><li>max: 52 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

S2ORCcitationsabstracts

—Dataset: S2ORCcitationsabstracts
—Size: 99,352 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 27 tokens</li><li>mean: 202.27 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 31 tokens</li><li>mean: 203.6 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 22 tokens</li><li>mean: 206.1 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

fever

—Dataset: fever
—Size: 74,514 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 6 tokens</li><li>mean: 12.35 tokens</li><li>max: 42 tokens</li></ul> | <ul><li>min: 101 tokens</li><li>mean: 112.23 tokens</li><li>max: 144 tokens</li></ul> | <ul><li>min: 45 tokens</li><li>mean: 113.54 tokens</li><li>max: 153 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

gooaq_pairs

—Dataset: gooaq_pairs
—Size: 24,838 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 8 tokens</li><li>mean: 11.89 tokens</li><li>max: 27 tokens</li></ul> | <ul><li>min: 15 tokens</li><li>mean: 60.01 tokens</li><li>max: 144 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 62.27 tokens</li><li>max: 154 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

codesearchnet

—Dataset: codesearchnet
—Size: 15,210 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 5 tokens</li><li>mean: 29.63 tokens</li><li>max: 240 tokens</li></ul> | <ul><li>min: 26 tokens</li><li>mean: 135.28 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 30 tokens</li><li>mean: 164.43 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

wikihow

—Dataset: wikihow
—Size: 5,070 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:---------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 4 tokens</li><li>mean: 7.97 tokens</li><li>max: 21 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 45.17 tokens</li><li>max: 134 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 36.47 tokens</li><li>max: 100 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

WikiAnswers

—Dataset: WikiAnswers
—Size: 24,838 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 6 tokens</li><li>mean: 12.82 tokens</li><li>max: 34 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 12.78 tokens</li><li>max: 46 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 13.14 tokens</li><li>max: 43 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

eli5questionanswer

—Dataset: eli5questionanswer
—Size: 24,838 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 4 tokens</li><li>mean: 20.24 tokens</li><li>max: 68 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 102.34 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 107.42 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

amazon-qa

—Dataset: amazon-qa
—Size: 99,352 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 6 tokens</li><li>mean: 23.25 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 15 tokens</li><li>mean: 54.71 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 19 tokens</li><li>mean: 62.56 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

medmcqa

—Dataset: medmcqa
—Size: 29,908 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 5 tokens</li><li>mean: 19.59 tokens</li><li>max: 176 tokens</li></ul> | <ul><li>min: 3 tokens</li><li>mean: 115.56 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 3 tokens</li><li>mean: 108.56 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

zeroshot

—Dataset: zeroshot
—Size: 15,210 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:---------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 5 tokens</li><li>mean: 8.65 tokens</li><li>max: 21 tokens</li></ul> | <ul><li>min: 15 tokens</li><li>mean: 111.48 tokens</li><li>max: 188 tokens</li></ul> | <ul><li>min: 21 tokens</li><li>mean: 117.19 tokens</li><li>max: 201 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

TriviaQA_pairs

—Dataset: TriviaQA_pairs
—Size: 49,676 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:---------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 8 tokens</li><li>mean: 19.3 tokens</li><li>max: 64 tokens</li></ul> | <ul><li>min: 19 tokens</li><li>mean: 245.22 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 51 tokens</li><li>mean: 234.74 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

PAQ_pairs

—Dataset: PAQ_pairs
—Size: 24,838 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 7 tokens</li><li>mean: 12.57 tokens</li><li>max: 21 tokens</li></ul> | <ul><li>min: 111 tokens</li><li>mean: 135.97 tokens</li><li>max: 194 tokens</li></ul> | <ul><li>min: 113 tokens</li><li>mean: 135.6 tokens</li><li>max: 254 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

stackexchangeduplicatequestionstitle-bodytitle-body

—Dataset: stackexchangeduplicatequestionstitle-bodytitle-body
—Size: 24,838 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 22 tokens</li><li>mean: 148.34 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 19 tokens</li><li>mean: 143.16 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 26 tokens</li><li>mean: 204.2 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

trex

—Dataset: trex
—Size: 29,908 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:---------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 5 tokens</li><li>mean: 9.53 tokens</li><li>max: 19 tokens</li></ul> | <ul><li>min: 17 tokens</li><li>mean: 103.23 tokens</li><li>max: 212 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 117.39 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

flickr30k_captions

—Dataset: flickr30k_captions
—Size: 24,838 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 6 tokens</li><li>mean: 16.02 tokens</li><li>max: 69 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 15.66 tokens</li><li>max: 65 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 16.84 tokens</li><li>max: 52 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

hotpotqa

—Dataset: hotpotqa
—Size: 40,048 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 7 tokens</li><li>mean: 23.98 tokens</li><li>max: 103 tokens</li></ul> | <ul><li>min: 29 tokens</li><li>mean: 113.77 tokens</li><li>max: 171 tokens</li></ul> | <ul><li>min: 13 tokens</li><li>mean: 115.06 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task671ambigqatext_generation

—Dataset: task671ambigqatext_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 11 tokens</li><li>mean: 12.71 tokens</li><li>max: 26 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 12.53 tokens</li><li>max: 23 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 12.23 tokens</li><li>max: 19 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task061ropesanswer_generation

—Dataset: task061ropesanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 117 tokens</li><li>mean: 209.08 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 117 tokens</li><li>mean: 208.33 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 119 tokens</li><li>mean: 210.46 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task285imdbanswer_generation

—Dataset: task285imdbanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 46 tokens</li><li>mean: 208.77 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 49 tokens</li><li>mean: 203.91 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 46 tokens</li><li>mean: 208.77 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task905hatespeechoffensiveclassification

—Dataset: task905hatespeechoffensiveclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 15 tokens</li><li>mean: 41.28 tokens</li><li>max: 164 tokens</li></ul> | <ul><li>min: 13 tokens</li><li>mean: 39.99 tokens</li><li>max: 198 tokens</li></ul> | <ul><li>min: 13 tokens</li><li>mean: 31.83 tokens</li><li>max: 135 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task566circaclassification

—Dataset: task566circaclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 20 tokens</li><li>mean: 27.77 tokens</li><li>max: 48 tokens</li></ul> | <ul><li>min: 19 tokens</li><li>mean: 27.2 tokens</li><li>max: 44 tokens</li></ul> | <ul><li>min: 20 tokens</li><li>mean: 27.44 tokens</li><li>max: 47 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task184snlientailmenttoneutraltextmodification

—Dataset: task184snlientailmenttoneutraltextmodification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 17 tokens</li><li>mean: 29.83 tokens</li><li>max: 72 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 28.91 tokens</li><li>max: 60 tokens</li></ul> | <ul><li>min: 17 tokens</li><li>mean: 30.32 tokens</li><li>max: 100 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task280stereosetclassificationstereotypetype

—Dataset: task280stereosetclassificationstereotypetype
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:---------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 8 tokens</li><li>mean: 18.5 tokens</li><li>max: 53 tokens</li></ul> | <ul><li>min: 8 tokens</li><li>mean: 16.86 tokens</li><li>max: 53 tokens</li></ul> | <ul><li>min: 8 tokens</li><li>mean: 16.92 tokens</li><li>max: 51 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1599smcalflowclassification

—Dataset: task1599smcalflowclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 3 tokens</li><li>mean: 11.26 tokens</li><li>max: 37 tokens</li></ul> | <ul><li>min: 3 tokens</li><li>mean: 10.49 tokens</li><li>max: 38 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 16.09 tokens</li><li>max: 45 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1384dealornodialog_classification

—Dataset: task1384dealornodialog_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 14 tokens</li><li>mean: 59.41 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 59.55 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 15 tokens</li><li>mean: 58.56 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task591sciqanswer_generation

—Dataset: task591sciqanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:---------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 8 tokens</li><li>mean: 17.59 tokens</li><li>max: 70 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 17.2 tokens</li><li>max: 43 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 16.64 tokens</li><li>max: 75 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task823peixian-rtgendersentiment_analysis

—Dataset: task823peixian-rtgendersentiment_analysis
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 16 tokens</li><li>mean: 56.95 tokens</li><li>max: 179 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 59.67 tokens</li><li>max: 153 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 60.1 tokens</li><li>max: 169 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task023cosmosqaquestion_generation

—Dataset: task023cosmosqaquestion_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 35 tokens</li><li>mean: 79.52 tokens</li><li>max: 159 tokens</li></ul> | <ul><li>min: 34 tokens</li><li>mean: 80.28 tokens</li><li>max: 165 tokens</li></ul> | <ul><li>min: 35 tokens</li><li>mean: 79.36 tokens</li><li>max: 161 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task900freebaseqacategoryclassification

—Dataset: task900freebaseqacategoryclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 8 tokens</li><li>mean: 20.33 tokens</li><li>max: 88 tokens</li></ul> | <ul><li>min: 8 tokens</li><li>mean: 18.15 tokens</li><li>max: 62 tokens</li></ul> | <ul><li>min: 8 tokens</li><li>mean: 18.96 tokens</li><li>max: 69 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task924event2mindword_generation

—Dataset: task924event2mindword_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 17 tokens</li><li>mean: 32.06 tokens</li><li>max: 64 tokens</li></ul> | <ul><li>min: 17 tokens</li><li>mean: 32.13 tokens</li><li>max: 70 tokens</li></ul> | <ul><li>min: 17 tokens</li><li>mean: 31.4 tokens</li><li>max: 68 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task152tomqafindlocationeasy_noise

—Dataset: task152tomqafindlocationeasy_noise
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 37 tokens</li><li>mean: 53.05 tokens</li><li>max: 79 tokens</li></ul> | <ul><li>min: 37 tokens</li><li>mean: 52.45 tokens</li><li>max: 78 tokens</li></ul> | <ul><li>min: 37 tokens</li><li>mean: 52.74 tokens</li><li>max: 82 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1368healthfactsentence_generation

—Dataset: task1368healthfactsentence_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 91 tokens</li><li>mean: 240.59 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 84 tokens</li><li>mean: 239.67 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 97 tokens</li><li>mean: 245.19 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1661superglue_classification

—Dataset: task1661superglue_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 35 tokens</li><li>mean: 141.23 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 31 tokens</li><li>mean: 142.83 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 31 tokens</li><li>mean: 143.19 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1187politifactclassification

—Dataset: task1187politifactclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 14 tokens</li><li>mean: 33.13 tokens</li><li>max: 79 tokens</li></ul> | <ul><li>min: 10 tokens</li><li>mean: 31.1 tokens</li><li>max: 75 tokens</li></ul> | <ul><li>min: 13 tokens</li><li>mean: 32.09 tokens</li><li>max: 71 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1728webnlgdatato_text

—Dataset: task1728webnlgdatato_text
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 7 tokens</li><li>mean: 43.18 tokens</li><li>max: 152 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 46.53 tokens</li><li>max: 152 tokens</li></ul> | <ul><li>min: 8 tokens</li><li>mean: 43.28 tokens</li><li>max: 152 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task112assetsimplesentenceidentification

—Dataset: task112assetsimplesentenceidentification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 18 tokens</li><li>mean: 52.12 tokens</li><li>max: 136 tokens</li></ul> | <ul><li>min: 18 tokens</li><li>mean: 52.01 tokens</li><li>max: 144 tokens</li></ul> | <ul><li>min: 22 tokens</li><li>mean: 51.99 tokens</li><li>max: 114 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1340msrtextcompressioncompression

—Dataset: task1340msrtextcompressioncompression
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 14 tokens</li><li>mean: 42.09 tokens</li><li>max: 116 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 44.57 tokens</li><li>max: 133 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 40.07 tokens</li><li>max: 141 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task072abductivenlianswer_generation

—Dataset: task072abductivenlianswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 17 tokens</li><li>mean: 26.82 tokens</li><li>max: 56 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 26.17 tokens</li><li>max: 47 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 26.36 tokens</li><li>max: 55 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1504hatexplainanswer_generation

—Dataset: task1504hatexplainanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 7 tokens</li><li>mean: 28.52 tokens</li><li>max: 72 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 24.07 tokens</li><li>max: 86 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 27.89 tokens</li><li>max: 67 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task684onlineprivacypolicytextinformationtype_generation

—Dataset: task684onlineprivacypolicytextinformationtype_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 10 tokens</li><li>mean: 29.93 tokens</li><li>max: 68 tokens</li></ul> | <ul><li>min: 10 tokens</li><li>mean: 30.14 tokens</li><li>max: 61 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 30.07 tokens</li><li>max: 68 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1290xsumsummarization

—Dataset: task1290xsumsummarization
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 39 tokens</li><li>mean: 226.29 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 50 tokens</li><li>mean: 229.57 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 34 tokens</li><li>mean: 230.56 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task075squad1.1answer_generation

—Dataset: task075squad1.1answer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 48 tokens</li><li>mean: 167.75 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 45 tokens</li><li>mean: 172.97 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 46 tokens</li><li>mean: 180.63 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1587scifactclassification

—Dataset: task1587scifactclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 88 tokens</li><li>mean: 241.61 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 90 tokens</li><li>mean: 246.28 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 86 tokens</li><li>mean: 244.31 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task384socialiqaquestion_classification

—Dataset: task384socialiqaquestion_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 24 tokens</li><li>mean: 35.44 tokens</li><li>max: 78 tokens</li></ul> | <ul><li>min: 22 tokens</li><li>mean: 34.38 tokens</li><li>max: 59 tokens</li></ul> | <ul><li>min: 22 tokens</li><li>mean: 34.58 tokens</li><li>max: 57 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1555scitailanswer_generation

—Dataset: task1555scitailanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 18 tokens</li><li>mean: 36.87 tokens</li><li>max: 90 tokens</li></ul> | <ul><li>min: 18 tokens</li><li>mean: 36.17 tokens</li><li>max: 80 tokens</li></ul> | <ul><li>min: 18 tokens</li><li>mean: 36.64 tokens</li><li>max: 92 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1532dailydialogemotionclassification

—Dataset: task1532dailydialogemotionclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 16 tokens</li><li>mean: 135.32 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 15 tokens</li><li>mean: 139.8 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 17 tokens</li><li>mean: 134.02 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task239tweetqaanswer_generation

—Dataset: task239tweetqaanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 28 tokens</li><li>mean: 56.06 tokens</li><li>max: 91 tokens</li></ul> | <ul><li>min: 29 tokens</li><li>mean: 56.54 tokens</li><li>max: 92 tokens</li></ul> | <ul><li>min: 25 tokens</li><li>mean: 56.09 tokens</li><li>max: 81 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task596mochaquestion_generation

—Dataset: task596mochaquestion_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 34 tokens</li><li>mean: 80.93 tokens</li><li>max: 163 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 95.61 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 10 tokens</li><li>mean: 45.71 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1411dartsubject_identification

—Dataset: task1411dartsubject_identification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 7 tokens</li><li>mean: 14.88 tokens</li><li>max: 74 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 14.04 tokens</li><li>max: 37 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 14.28 tokens</li><li>max: 37 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1359numersenseanswergeneration

—Dataset: task1359numersenseanswergeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 10 tokens</li><li>mean: 18.76 tokens</li><li>max: 30 tokens</li></ul> | <ul><li>min: 10 tokens</li><li>mean: 18.44 tokens</li><li>max: 33 tokens</li></ul> | <ul><li>min: 10 tokens</li><li>mean: 18.29 tokens</li><li>max: 30 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task329gapclassification

—Dataset: task329gapclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 40 tokens</li><li>mean: 123.84 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 62 tokens</li><li>mean: 127.37 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 58 tokens</li><li>mean: 128.52 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task220rocstoriestitle_classification

—Dataset: task220rocstoriestitle_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 53 tokens</li><li>mean: 80.89 tokens</li><li>max: 116 tokens</li></ul> | <ul><li>min: 51 tokens</li><li>mean: 81.18 tokens</li><li>max: 108 tokens</li></ul> | <ul><li>min: 55 tokens</li><li>mean: 79.93 tokens</li><li>max: 115 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task316crows-pairsclassification_stereotype

—Dataset: task316crows-pairsclassification_stereotype
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:---------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 8 tokens</li><li>mean: 19.8 tokens</li><li>max: 51 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 18.21 tokens</li><li>max: 41 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 19.89 tokens</li><li>max: 52 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task495semevalheadline_classification

—Dataset: task495semevalheadline_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 17 tokens</li><li>mean: 24.55 tokens</li><li>max: 42 tokens</li></ul> | <ul><li>min: 15 tokens</li><li>mean: 24.2 tokens</li><li>max: 41 tokens</li></ul> | <ul><li>min: 15 tokens</li><li>mean: 24.21 tokens</li><li>max: 38 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1168browncoarsepostagging

—Dataset: task1168browncoarsepostagging
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 13 tokens</li><li>mean: 43.79 tokens</li><li>max: 142 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 43.44 tokens</li><li>max: 197 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 44.73 tokens</li><li>max: 197 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task348squad2.0unanswerablequestiongeneration

—Dataset: task348squad2.0unanswerablequestiongeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 30 tokens</li><li>mean: 153.12 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 38 tokens</li><li>mean: 161.18 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 33 tokens</li><li>mean: 165.66 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task049multircquestionsneededto_answer

—Dataset: task049multircquestionsneededto_answer
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 174 tokens</li><li>mean: 252.51 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 169 tokens</li><li>mean: 252.54 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 178 tokens</li><li>mean: 252.7 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1534dailydialogquestionclassification

—Dataset: task1534dailydialogquestionclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 17 tokens</li><li>mean: 125.74 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 15 tokens</li><li>mean: 131.07 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 134.47 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task322jigsawclassification_threat

—Dataset: task322jigsawclassification_threat
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 7 tokens</li><li>mean: 54.67 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 61.63 tokens</li><li>max: 249 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 62.02 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task295semeval2020task4commonsense_reasoning

—Dataset: task295semeval2020task4commonsense_reasoning
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 25 tokens</li><li>mean: 44.89 tokens</li><li>max: 92 tokens</li></ul> | <ul><li>min: 25 tokens</li><li>mean: 45.09 tokens</li><li>max: 95 tokens</li></ul> | <ul><li>min: 25 tokens</li><li>mean: 44.66 tokens</li><li>max: 88 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task186snlicontradictiontoentailmenttextmodification

—Dataset: task186snlicontradictiontoentailmenttextmodification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 18 tokens</li><li>mean: 31.14 tokens</li><li>max: 102 tokens</li></ul> | <ul><li>min: 18 tokens</li><li>mean: 30.23 tokens</li><li>max: 65 tokens</li></ul> | <ul><li>min: 18 tokens</li><li>mean: 32.2 tokens</li><li>max: 67 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task034winograndequestionmodificationobject

—Dataset: task034winograndequestionmodificationobject
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 29 tokens</li><li>mean: 36.34 tokens</li><li>max: 53 tokens</li></ul> | <ul><li>min: 29 tokens</li><li>mean: 35.58 tokens</li><li>max: 54 tokens</li></ul> | <ul><li>min: 29 tokens</li><li>mean: 34.86 tokens</li><li>max: 55 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task160replaceletterina_sentence

—Dataset: task160replaceletterina_sentence
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 29 tokens</li><li>mean: 32.0 tokens</li><li>max: 49 tokens</li></ul> | <ul><li>min: 28 tokens</li><li>mean: 31.76 tokens</li><li>max: 41 tokens</li></ul> | <ul><li>min: 29 tokens</li><li>mean: 31.76 tokens</li><li>max: 48 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task469mrqaanswer_generation

—Dataset: task469mrqaanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 27 tokens</li><li>mean: 182.03 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 25 tokens</li><li>mean: 180.72 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 27 tokens</li><li>mean: 184.12 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task105storycloze-rocstoriessentencegeneration

—Dataset: task105storycloze-rocstoriessentencegeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 36 tokens</li><li>mean: 55.59 tokens</li><li>max: 75 tokens</li></ul> | <ul><li>min: 35 tokens</li><li>mean: 54.86 tokens</li><li>max: 76 tokens</li></ul> | <ul><li>min: 36 tokens</li><li>mean: 55.91 tokens</li><li>max: 76 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task649raceblankquestiongeneration

—Dataset: task649raceblankquestiongeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 36 tokens</li><li>mean: 253.21 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 36 tokens</li><li>mean: 252.85 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 157 tokens</li><li>mean: 254.06 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1536dailydialoghappinessclassification

—Dataset: task1536dailydialoghappinessclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 13 tokens</li><li>mean: 128.15 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 13 tokens</li><li>mean: 134.78 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 142.94 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task683onlineprivacypolicytextpurposeanswer_generation

—Dataset: task683onlineprivacypolicytextpurposeanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 10 tokens</li><li>mean: 30.15 tokens</li><li>max: 68 tokens</li></ul> | <ul><li>min: 10 tokens</li><li>mean: 30.54 tokens</li><li>max: 64 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 30.02 tokens</li><li>max: 68 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task024cosmosqaanswer_generation

—Dataset: task024cosmosqaanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 45 tokens</li><li>mean: 92.7 tokens</li><li>max: 176 tokens</li></ul> | <ul><li>min: 47 tokens</li><li>mean: 93.25 tokens</li><li>max: 174 tokens</li></ul> | <ul><li>min: 42 tokens</li><li>mean: 94.77 tokens</li><li>max: 183 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task584udepsengfinepos_tagging

—Dataset: task584udepsengfinepos_tagging
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 12 tokens</li><li>mean: 40.06 tokens</li><li>max: 120 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 39.44 tokens</li><li>max: 186 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 40.24 tokens</li><li>max: 148 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task066timetravelbinaryconsistencyclassification

—Dataset: task066timetravelbinaryconsistencyclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 42 tokens</li><li>mean: 66.78 tokens</li><li>max: 93 tokens</li></ul> | <ul><li>min: 43 tokens</li><li>mean: 67.31 tokens</li><li>max: 94 tokens</li></ul> | <ul><li>min: 45 tokens</li><li>mean: 67.08 tokens</li><li>max: 92 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task413mickeyensentenceperturbation_generation

—Dataset: task413mickeyensentenceperturbation_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 7 tokens</li><li>mean: 13.73 tokens</li><li>max: 21 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 13.78 tokens</li><li>max: 21 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 13.25 tokens</li><li>max: 20 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task182duorcquestion_generation

—Dataset: task182duorcquestion_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 99 tokens</li><li>mean: 242.74 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 120 tokens</li><li>mean: 246.39 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 99 tokens</li><li>mean: 246.34 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task028dropanswer_generation

—Dataset: task028dropanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 76 tokens</li><li>mean: 230.41 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 86 tokens</li><li>mean: 234.25 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 81 tokens</li><li>mean: 235.63 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1601webquestionsanswer_generation

—Dataset: task1601webquestionsanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 9 tokens</li><li>mean: 16.52 tokens</li><li>max: 28 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 16.69 tokens</li><li>max: 28 tokens</li></ul> | <ul><li>min: 9 tokens</li><li>mean: 16.73 tokens</li><li>max: 27 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1295adversarialqaquestionanswering

—Dataset: task1295adversarialqaquestionanswering
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 45 tokens</li><li>mean: 165.73 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 54 tokens</li><li>mean: 166.67 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 48 tokens</li><li>mean: 167.91 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task201mnlineutral_classification

—Dataset: task201mnlineutral_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 24 tokens</li><li>mean: 72.84 tokens</li><li>max: 218 tokens</li></ul> | <ul><li>min: 25 tokens</li><li>mean: 73.23 tokens</li><li>max: 170 tokens</li></ul> | <ul><li>min: 27 tokens</li><li>mean: 72.49 tokens</li><li>max: 205 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task038qasccombined_fact

—Dataset: task038qasccombined_fact
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 18 tokens</li><li>mean: 31.2 tokens</li><li>max: 57 tokens</li></ul> | <ul><li>min: 19 tokens</li><li>mean: 30.5 tokens</li><li>max: 53 tokens</li></ul> | <ul><li>min: 18 tokens</li><li>mean: 30.87 tokens</li><li>max: 53 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task293storycommonsenseemotiontextgeneration

—Dataset: task293storycommonsenseemotiontextgeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 14 tokens</li><li>mean: 40.14 tokens</li><li>max: 86 tokens</li></ul> | <ul><li>min: 15 tokens</li><li>mean: 40.19 tokens</li><li>max: 86 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 37.76 tokens</li><li>max: 86 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task572recipenlgtextgeneration

—Dataset: task572recipenlgtextgeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 24 tokens</li><li>mean: 115.21 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 24 tokens</li><li>mean: 120.85 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 24 tokens</li><li>mean: 124.55 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task517emoclassifyemotionof_dialogue

—Dataset: task517emoclassifyemotionof_dialogue
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 7 tokens</li><li>mean: 18.11 tokens</li><li>max: 78 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 16.92 tokens</li><li>max: 59 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 18.35 tokens</li><li>max: 67 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task382hybridqaanswer_generation

—Dataset: task382hybridqaanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 29 tokens</li><li>mean: 42.31 tokens</li><li>max: 70 tokens</li></ul> | <ul><li>min: 29 tokens</li><li>mean: 41.59 tokens</li><li>max: 74 tokens</li></ul> | <ul><li>min: 28 tokens</li><li>mean: 41.72 tokens</li><li>max: 75 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task176breakdecompose_questions

—Dataset: task176breakdecompose_questions
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 9 tokens</li><li>mean: 17.55 tokens</li><li>max: 41 tokens</li></ul> | <ul><li>min: 8 tokens</li><li>mean: 17.27 tokens</li><li>max: 39 tokens</li></ul> | <ul><li>min: 8 tokens</li><li>mean: 15.76 tokens</li><li>max: 38 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1291multinews_summarization

—Dataset: task1291multinews_summarization
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:--------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 116 tokens</li><li>mean: 255.36 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 146 tokens</li><li>mean: 255.6 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 68 tokens</li><li>mean: 251.68 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task155countnouns_verbs

—Dataset: task155countnouns_verbs
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 23 tokens</li><li>mean: 27.01 tokens</li><li>max: 56 tokens</li></ul> | <ul><li>min: 23 tokens</li><li>mean: 26.8 tokens</li><li>max: 43 tokens</li></ul> | <ul><li>min: 23 tokens</li><li>mean: 26.96 tokens</li><li>max: 46 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task031winograndequestiongenerationobject

—Dataset: task031winograndequestiongenerationobject
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:---------------------------------------------------------------------------------|:--------------------------------------------------------------------------------|:---------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 7 tokens</li><li>mean: 7.43 tokens</li><li>max: 11 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 7.3 tokens</li><li>max: 11 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 7.26 tokens</li><li>max: 11 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task279stereosetclassification_stereotype

—Dataset: task279stereosetclassification_stereotype
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 8 tokens</li><li>mean: 17.92 tokens</li><li>max: 41 tokens</li></ul> | <ul><li>min: 8 tokens</li><li>mean: 15.59 tokens</li><li>max: 43 tokens</li></ul> | <ul><li>min: 8 tokens</li><li>mean: 17.41 tokens</li><li>max: 50 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1336peixianequityevaluationcorpusgenderclassifier

—Dataset: task1336peixianequityevaluationcorpusgenderclassifier
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:---------------------------------------------------------------------------------|:--------------------------------------------------------------------------------|:---------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 6 tokens</li><li>mean: 9.61 tokens</li><li>max: 17 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 9.6 tokens</li><li>max: 16 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 9.69 tokens</li><li>max: 16 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task508scruplesdilemmasmoreethical_isidentifiable

—Dataset: task508scruplesdilemmasmoreethical_isidentifiable
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 12 tokens</li><li>mean: 29.82 tokens</li><li>max: 94 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 28.66 tokens</li><li>max: 94 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 28.61 tokens</li><li>max: 86 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task518emodifferentdialogueemotions

—Dataset: task518emodifferentdialogueemotions
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 28 tokens</li><li>mean: 47.96 tokens</li><li>max: 106 tokens</li></ul> | <ul><li>min: 28 tokens</li><li>mean: 45.39 tokens</li><li>max: 116 tokens</li></ul> | <ul><li>min: 26 tokens</li><li>mean: 45.93 tokens</li><li>max: 123 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task077splashexplanationtosql

—Dataset: task077splashexplanationtosql
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 8 tokens</li><li>mean: 40.04 tokens</li><li>max: 126 tokens</li></ul> | <ul><li>min: 8 tokens</li><li>mean: 40.2 tokens</li><li>max: 126 tokens</li></ul> | <ul><li>min: 8 tokens</li><li>mean: 35.92 tokens</li><li>max: 111 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task923event2mindclassifier

—Dataset: task923event2mindclassifier
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 10 tokens</li><li>mean: 20.63 tokens</li><li>max: 46 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 18.67 tokens</li><li>max: 41 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 19.69 tokens</li><li>max: 46 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task470mrqaquestion_generation

—Dataset: task470mrqaquestion_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 13 tokens</li><li>mean: 169.2 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 171.57 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 177.27 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task638multiwoz_classification

—Dataset: task638multiwoz_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 78 tokens</li><li>mean: 223.46 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 76 tokens</li><li>mean: 220.37 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 64 tokens</li><li>mean: 220.24 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1412webquestionsquestionanswering

—Dataset: task1412webquestionsquestionanswering
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 6 tokens</li><li>mean: 10.33 tokens</li><li>max: 17 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 10.18 tokens</li><li>max: 17 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 10.06 tokens</li><li>max: 16 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task847pubmedqaquestion_generation

—Dataset: task847pubmedqaquestion_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 21 tokens</li><li>mean: 248.9 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 21 tokens</li><li>mean: 248.61 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 43 tokens</li><li>mean: 248.81 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task678ollieactualrelationshipanswer_generation

—Dataset: task678ollieactualrelationshipanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 20 tokens</li><li>mean: 40.81 tokens</li><li>max: 95 tokens</li></ul> | <ul><li>min: 19 tokens</li><li>mean: 38.16 tokens</li><li>max: 102 tokens</li></ul> | <ul><li>min: 18 tokens</li><li>mean: 41.16 tokens</li><li>max: 104 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task290tellmewhyquestion_answerability

—Dataset: task290tellmewhyquestion_answerability
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 37 tokens</li><li>mean: 62.98 tokens</li><li>max: 95 tokens</li></ul> | <ul><li>min: 36 tokens</li><li>mean: 62.44 tokens</li><li>max: 94 tokens</li></ul> | <ul><li>min: 37 tokens</li><li>mean: 63.21 tokens</li><li>max: 95 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task575airdialogue_classification

—Dataset: task575airdialogue_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 4 tokens</li><li>mean: 14.15 tokens</li><li>max: 45 tokens</li></ul> | <ul><li>min: 4 tokens</li><li>mean: 13.51 tokens</li><li>max: 43 tokens</li></ul> | <ul><li>min: 4 tokens</li><li>mean: 12.27 tokens</li><li>max: 42 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task189snlineutraltocontradictiontextmodification

—Dataset: task189snlineutraltocontradictiontextmodification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 18 tokens</li><li>mean: 31.83 tokens</li><li>max: 60 tokens</li></ul> | <ul><li>min: 18 tokens</li><li>mean: 30.73 tokens</li><li>max: 57 tokens</li></ul> | <ul><li>min: 18 tokens</li><li>mean: 33.28 tokens</li><li>max: 105 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task026dropquestion_generation

—Dataset: task026dropquestion_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 82 tokens</li><li>mean: 219.14 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 57 tokens</li><li>mean: 222.86 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 96 tokens</li><li>mean: 232.16 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task162countwordsstartingwith_letter

—Dataset: task162countwordsstartingwith_letter
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 28 tokens</li><li>mean: 32.17 tokens</li><li>max: 56 tokens</li></ul> | <ul><li>min: 28 tokens</li><li>mean: 31.79 tokens</li><li>max: 45 tokens</li></ul> | <ul><li>min: 28 tokens</li><li>mean: 31.64 tokens</li><li>max: 46 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task079conalaconcat_strings

—Dataset: task079conalaconcat_strings
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 11 tokens</li><li>mean: 39.84 tokens</li><li>max: 76 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 34.25 tokens</li><li>max: 80 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 33.76 tokens</li><li>max: 76 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task610conllppner

—Dataset: task610conllppner
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 4 tokens</li><li>mean: 19.52 tokens</li><li>max: 62 tokens</li></ul> | <ul><li>min: 4 tokens</li><li>mean: 20.22 tokens</li><li>max: 62 tokens</li></ul> | <ul><li>min: 4 tokens</li><li>mean: 14.17 tokens</li><li>max: 54 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task046miscellaneousquestion_typing

—Dataset: task046miscellaneousquestion_typing
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 16 tokens</li><li>mean: 25.34 tokens</li><li>max: 70 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 24.91 tokens</li><li>max: 70 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 25.13 tokens</li><li>max: 57 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task197mnlidomainanswergeneration

—Dataset: task197mnlidomainanswergeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 15 tokens</li><li>mean: 44.01 tokens</li><li>max: 197 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 45.3 tokens</li><li>max: 211 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 39.46 tokens</li><li>max: 115 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1325qazrequestiongenerationonsubject_relation

—Dataset: task1325qazrequestiongenerationonsubject_relation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 18 tokens</li><li>mean: 50.88 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 20 tokens</li><li>mean: 49.59 tokens</li><li>max: 180 tokens</li></ul> | <ul><li>min: 22 tokens</li><li>mean: 54.07 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task430sentevalsubject_count

—Dataset: task430sentevalsubject_count
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:---------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 7 tokens</li><li>mean: 17.27 tokens</li><li>max: 35 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 15.28 tokens</li><li>max: 34 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 16.2 tokens</li><li>max: 34 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task672_nummersense

—Dataset: task672_nummersense
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 7 tokens</li><li>mean: 15.67 tokens</li><li>max: 30 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 15.31 tokens</li><li>max: 27 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 15.18 tokens</li><li>max: 30 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task402grailqaparaphrase_generation

—Dataset: task402grailqaparaphrase_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 23 tokens</li><li>mean: 128.15 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 24 tokens</li><li>mean: 139.32 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 22 tokens</li><li>mean: 134.5 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task904hatespeechoffensiveclassification

—Dataset: task904hatespeechoffensiveclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 8 tokens</li><li>mean: 35.26 tokens</li><li>max: 157 tokens</li></ul> | <ul><li>min: 8 tokens</li><li>mean: 34.84 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 28.03 tokens</li><li>max: 148 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task192hotpotqasentence_generation

—Dataset: task192hotpotqasentence_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 37 tokens</li><li>mean: 125.97 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 35 tokens</li><li>mean: 124.56 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 33 tokens</li><li>mean: 134.36 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task069abductivenliclassification

—Dataset: task069abductivenliclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 33 tokens</li><li>mean: 52.08 tokens</li><li>max: 86 tokens</li></ul> | <ul><li>min: 33 tokens</li><li>mean: 52.1 tokens</li><li>max: 95 tokens</li></ul> | <ul><li>min: 33 tokens</li><li>mean: 51.91 tokens</li><li>max: 95 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task574airdialoguesentencegeneration

—Dataset: task574airdialoguesentencegeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 54 tokens</li><li>mean: 144.65 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 57 tokens</li><li>mean: 144.28 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 66 tokens</li><li>mean: 147.96 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task187snlientailmenttocontradictiontextmodification

—Dataset: task187snlientailmenttocontradictiontextmodification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 16 tokens</li><li>mean: 30.3 tokens</li><li>max: 69 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 30.02 tokens</li><li>max: 104 tokens</li></ul> | <ul><li>min: 17 tokens</li><li>mean: 29.39 tokens</li><li>max: 71 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task749glucosereversecauseemotion_detection

—Dataset: task749glucosereversecauseemotion_detection
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 38 tokens</li><li>mean: 67.55 tokens</li><li>max: 106 tokens</li></ul> | <ul><li>min: 37 tokens</li><li>mean: 67.08 tokens</li><li>max: 104 tokens</li></ul> | <ul><li>min: 39 tokens</li><li>mean: 68.46 tokens</li><li>max: 107 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1552scitailquestion_generation

—Dataset: task1552scitailquestion_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 7 tokens</li><li>mean: 18.32 tokens</li><li>max: 53 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 17.52 tokens</li><li>max: 46 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 15.91 tokens</li><li>max: 54 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task750aquamultiplechoiceanswering

—Dataset: task750aquamultiplechoiceanswering
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 33 tokens</li><li>mean: 69.75 tokens</li><li>max: 194 tokens</li></ul> | <ul><li>min: 32 tokens</li><li>mean: 68.09 tokens</li><li>max: 194 tokens</li></ul> | <ul><li>min: 28 tokens</li><li>mean: 67.92 tokens</li><li>max: 165 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task327jigsawclassification_toxic

—Dataset: task327jigsawclassification_toxic
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 5 tokens</li><li>mean: 36.4 tokens</li><li>max: 234 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 40.47 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 44.97 tokens</li><li>max: 244 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1502hatexplainclassification

—Dataset: task1502hatexplainclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 5 tokens</li><li>mean: 28.73 tokens</li><li>max: 73 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 26.79 tokens</li><li>max: 110 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 27.16 tokens</li><li>max: 90 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task328jigsawclassification_insult

—Dataset: task328jigsawclassification_insult
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 5 tokens</li><li>mean: 51.49 tokens</li><li>max: 247 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 60.84 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 64.97 tokens</li><li>max: 249 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task304numericfusedheadresolution

—Dataset: task304numericfusedheadresolution
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 15 tokens</li><li>mean: 120.74 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 120.45 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 134.37 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1293kilttaskshotpotqaquestion_answering

—Dataset: task1293kilttaskshotpotqaquestion_answering
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:---------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 10 tokens</li><li>mean: 24.74 tokens</li><li>max: 114 tokens</li></ul> | <ul><li>min: 9 tokens</li><li>mean: 24.23 tokens</li><li>max: 114 tokens</li></ul> | <ul><li>min: 8 tokens</li><li>mean: 23.8 tokens</li><li>max: 84 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task216rocstoriescorrectanswergeneration

—Dataset: task216rocstoriescorrectanswergeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 39 tokens</li><li>mean: 59.55 tokens</li><li>max: 83 tokens</li></ul> | <ul><li>min: 36 tokens</li><li>mean: 58.45 tokens</li><li>max: 92 tokens</li></ul> | <ul><li>min: 39 tokens</li><li>mean: 58.16 tokens</li><li>max: 95 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1326qazrequestiongenerationfromanswer

—Dataset: task1326qazrequestiongenerationfromanswer
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 17 tokens</li><li>mean: 46.62 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 45.45 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 18 tokens</li><li>mean: 49.75 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1338peixianequityevaluationcorpussentimentclassifier

—Dataset: task1338peixianequityevaluationcorpussentimentclassifier
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:---------------------------------------------------------------------------------|:---------------------------------------------------------------------------------|:--------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 6 tokens</li><li>mean: 9.71 tokens</li><li>max: 16 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 9.72 tokens</li><li>max: 16 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 9.6 tokens</li><li>max: 17 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1729personachatgenerate_next

—Dataset: task1729personachatgenerate_next
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 44 tokens</li><li>mean: 146.51 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 43 tokens</li><li>mean: 142.18 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 50 tokens</li><li>mean: 144.65 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1202atomicclassification_xneed

—Dataset: task1202atomicclassification_xneed
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 14 tokens</li><li>mean: 19.55 tokens</li><li>max: 32 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 19.37 tokens</li><li>max: 31 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 19.24 tokens</li><li>max: 28 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task400pawsparaphrase_classification

—Dataset: task400pawsparaphrase_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 19 tokens</li><li>mean: 52.33 tokens</li><li>max: 97 tokens</li></ul> | <ul><li>min: 18 tokens</li><li>mean: 51.86 tokens</li><li>max: 98 tokens</li></ul> | <ul><li>min: 19 tokens</li><li>mean: 53.06 tokens</li><li>max: 97 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task502scruplesanecdoteswhoiswrongverification

—Dataset: task502scruplesanecdoteswhoiswrongverification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 12 tokens</li><li>mean: 230.07 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 236.26 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 23 tokens</li><li>mean: 235.04 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task088identifytypo_verification

—Dataset: task088identifytypo_verification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 11 tokens</li><li>mean: 15.05 tokens</li><li>max: 48 tokens</li></ul> | <ul><li>min: 10 tokens</li><li>mean: 15.04 tokens</li><li>max: 47 tokens</li></ul> | <ul><li>min: 10 tokens</li><li>mean: 15.37 tokens</li><li>max: 47 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task221rocstoriestwochoiceclassification

—Dataset: task221rocstoriestwochoiceclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 47 tokens</li><li>mean: 72.49 tokens</li><li>max: 108 tokens</li></ul> | <ul><li>min: 48 tokens</li><li>mean: 72.55 tokens</li><li>max: 109 tokens</li></ul> | <ul><li>min: 46 tokens</li><li>mean: 73.14 tokens</li><li>max: 108 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task200mnlientailment_classification

—Dataset: task200mnlientailment_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 24 tokens</li><li>mean: 72.91 tokens</li><li>max: 198 tokens</li></ul> | <ul><li>min: 23 tokens</li><li>mean: 72.85 tokens</li><li>max: 224 tokens</li></ul> | <ul><li>min: 23 tokens</li><li>mean: 74.37 tokens</li><li>max: 226 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task074squad1.1question_generation

—Dataset: task074squad1.1question_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 30 tokens</li><li>mean: 149.96 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 33 tokens</li><li>mean: 161.12 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 38 tokens</li><li>mean: 164.99 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task581socialiqaquestion_generation

—Dataset: task581socialiqaquestion_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 12 tokens</li><li>mean: 26.5 tokens</li><li>max: 69 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 25.51 tokens</li><li>max: 48 tokens</li></ul> | <ul><li>min: 15 tokens</li><li>mean: 25.89 tokens</li><li>max: 48 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1186nnehrngo_classification

—Dataset: task1186nnehrngo_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 19 tokens</li><li>mean: 33.87 tokens</li><li>max: 79 tokens</li></ul> | <ul><li>min: 19 tokens</li><li>mean: 33.57 tokens</li><li>max: 74 tokens</li></ul> | <ul><li>min: 20 tokens</li><li>mean: 33.51 tokens</li><li>max: 77 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task898freebaseqaanswergeneration

—Dataset: task898freebaseqaanswergeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:---------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 8 tokens</li><li>mean: 19.1 tokens</li><li>max: 125 tokens</li></ul> | <ul><li>min: 8 tokens</li><li>mean: 17.5 tokens</li><li>max: 49 tokens</li></ul> | <ul><li>min: 8 tokens</li><li>mean: 17.35 tokens</li><li>max: 79 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1408dartsimilarity_classification

—Dataset: task1408dartsimilarity_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 22 tokens</li><li>mean: 59.52 tokens</li><li>max: 147 tokens</li></ul> | <ul><li>min: 22 tokens</li><li>mean: 62.01 tokens</li><li>max: 154 tokens</li></ul> | <ul><li>min: 20 tokens</li><li>mean: 48.27 tokens</li><li>max: 124 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task168strategyqaquestion_decomposition

—Dataset: task168strategyqaquestion_decomposition
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 42 tokens</li><li>mean: 82.11 tokens</li><li>max: 181 tokens</li></ul> | <ul><li>min: 42 tokens</li><li>mean: 80.29 tokens</li><li>max: 179 tokens</li></ul> | <ul><li>min: 42 tokens</li><li>mean: 77.42 tokens</li><li>max: 166 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1357xlsumsummary_generation

—Dataset: task1357xlsumsummary_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 67 tokens</li><li>mean: 241.82 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 69 tokens</li><li>mean: 243.59 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 67 tokens</li><li>mean: 246.59 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task390torquetextspanselection

—Dataset: task390torquetextspanselection
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 47 tokens</li><li>mean: 110.15 tokens</li><li>max: 196 tokens</li></ul> | <ul><li>min: 42 tokens</li><li>mean: 110.7 tokens</li><li>max: 195 tokens</li></ul> | <ul><li>min: 48 tokens</li><li>mean: 110.55 tokens</li><li>max: 196 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task165mcscriptquestionansweringcommonsense

—Dataset: task165mcscriptquestionansweringcommonsense
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 147 tokens</li><li>mean: 198.53 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 145 tokens</li><li>mean: 197.05 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 147 tokens</li><li>mean: 198.89 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1533dailydialogformalclassification

—Dataset: task1533dailydialogformalclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 13 tokens</li><li>mean: 129.3 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 15 tokens</li><li>mean: 136.35 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 17 tokens</li><li>mean: 137.22 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task002quorefanswer_generation

—Dataset: task002quorefanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:--------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 214 tokens</li><li>mean: 255.53 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 214 tokens</li><li>mean: 255.5 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 224 tokens</li><li>mean: 255.61 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1297qascquestion_answering

—Dataset: task1297qascquestion_answering
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 61 tokens</li><li>mean: 84.59 tokens</li><li>max: 134 tokens</li></ul> | <ul><li>min: 59 tokens</li><li>mean: 85.4 tokens</li><li>max: 130 tokens</li></ul> | <ul><li>min: 58 tokens</li><li>mean: 84.82 tokens</li><li>max: 125 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task305jeopardyanswergenerationnormal

—Dataset: task305jeopardyanswergenerationnormal
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:---------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 9 tokens</li><li>mean: 27.7 tokens</li><li>max: 59 tokens</li></ul> | <ul><li>min: 9 tokens</li><li>mean: 27.39 tokens</li><li>max: 45 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 27.4 tokens</li><li>max: 46 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task029winograndefull_object

—Dataset: task029winograndefull_object
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:---------------------------------------------------------------------------------|:---------------------------------------------------------------------------------|:---------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 7 tokens</li><li>mean: 7.38 tokens</li><li>max: 12 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 7.33 tokens</li><li>max: 11 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 7.24 tokens</li><li>max: 10 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1327qazreanswergenerationfromquestion

—Dataset: task1327qazreanswergenerationfromquestion
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 24 tokens</li><li>mean: 54.62 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 23 tokens</li><li>mean: 51.93 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 27 tokens</li><li>mean: 55.18 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task326jigsawclassification_obscene

—Dataset: task326jigsawclassification_obscene
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 5 tokens</li><li>mean: 65.08 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 77.16 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 72.91 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1542everyithelementfrom_starting

—Dataset: task1542everyithelementfrom_starting
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 13 tokens</li><li>mean: 126.68 tokens</li><li>max: 245 tokens</li></ul> | <ul><li>min: 13 tokens</li><li>mean: 125.19 tokens</li><li>max: 244 tokens</li></ul> | <ul><li>min: 13 tokens</li><li>mean: 122.85 tokens</li><li>max: 238 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task570recipenlgnergeneration

—Dataset: task570recipenlgnergeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 11 tokens</li><li>mean: 74.21 tokens</li><li>max: 250 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 73.66 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 8 tokens</li><li>mean: 76.18 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1409darttext_generation

—Dataset: task1409darttext_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 18 tokens</li><li>mean: 67.37 tokens</li><li>max: 174 tokens</li></ul> | <ul><li>min: 18 tokens</li><li>mean: 72.58 tokens</li><li>max: 170 tokens</li></ul> | <ul><li>min: 17 tokens</li><li>mean: 67.5 tokens</li><li>max: 164 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task401numericfusedheadreference

—Dataset: task401numericfusedheadreference
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 16 tokens</li><li>mean: 109.69 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 117.49 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 18 tokens</li><li>mean: 120.19 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task846pubmedqaclassification

—Dataset: task846pubmedqaclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 32 tokens</li><li>mean: 85.93 tokens</li><li>max: 246 tokens</li></ul> | <ul><li>min: 33 tokens</li><li>mean: 85.28 tokens</li><li>max: 225 tokens</li></ul> | <ul><li>min: 28 tokens</li><li>mean: 93.93 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1712pokiclassification

—Dataset: task1712pokiclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 6 tokens</li><li>mean: 52.12 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 54.86 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 8 tokens</li><li>mean: 63.21 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task344hybridqaanswer_generation

—Dataset: task344hybridqaanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 9 tokens</li><li>mean: 22.22 tokens</li><li>max: 50 tokens</li></ul> | <ul><li>min: 8 tokens</li><li>mean: 22.05 tokens</li><li>max: 58 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 22.06 tokens</li><li>max: 55 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task875emotionclassification

—Dataset: task875emotionclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 4 tokens</li><li>mean: 23.27 tokens</li><li>max: 75 tokens</li></ul> | <ul><li>min: 4 tokens</li><li>mean: 18.54 tokens</li><li>max: 63 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 20.34 tokens</li><li>max: 68 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1214atomicclassification_xwant

—Dataset: task1214atomicclassification_xwant
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 14 tokens</li><li>mean: 19.64 tokens</li><li>max: 32 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 19.45 tokens</li><li>max: 29 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 19.53 tokens</li><li>max: 31 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task106scruplesethical_judgment

—Dataset: task106scruplesethical_judgment
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 12 tokens</li><li>mean: 30.02 tokens</li><li>max: 70 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 29.03 tokens</li><li>max: 86 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 28.76 tokens</li><li>max: 58 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task238iircanswerfrompassageanswergeneration

—Dataset: task238iircanswerfrompassageanswergeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 138 tokens</li><li>mean: 242.56 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 165 tokens</li><li>mean: 242.71 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 173 tokens</li><li>mean: 242.96 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1391winograndeeasyanswergeneration

—Dataset: task1391winograndeeasyanswergeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 26 tokens</li><li>mean: 31.71 tokens</li><li>max: 54 tokens</li></ul> | <ul><li>min: 26 tokens</li><li>mean: 31.3 tokens</li><li>max: 48 tokens</li></ul> | <ul><li>min: 25 tokens</li><li>mean: 31.21 tokens</li><li>max: 49 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task195sentiment140classification

—Dataset: task195sentiment140classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 4 tokens</li><li>mean: 22.5 tokens</li><li>max: 118 tokens</li></ul> | <ul><li>min: 4 tokens</li><li>mean: 18.92 tokens</li><li>max: 79 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 21.41 tokens</li><li>max: 51 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task163countwordsendingwith_letter

—Dataset: task163countwordsendingwith_letter
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 28 tokens</li><li>mean: 31.97 tokens</li><li>max: 54 tokens</li></ul> | <ul><li>min: 28 tokens</li><li>mean: 31.7 tokens</li><li>max: 57 tokens</li></ul> | <ul><li>min: 28 tokens</li><li>mean: 31.59 tokens</li><li>max: 43 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task579socialiqaclassification

—Dataset: task579socialiqaclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 39 tokens</li><li>mean: 53.99 tokens</li><li>max: 132 tokens</li></ul> | <ul><li>min: 36 tokens</li><li>mean: 53.65 tokens</li><li>max: 103 tokens</li></ul> | <ul><li>min: 40 tokens</li><li>mean: 54.15 tokens</li><li>max: 84 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task569recipenlgtextgeneration

—Dataset: task569recipenlgtextgeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 25 tokens</li><li>mean: 193.26 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 55 tokens</li><li>mean: 193.24 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 37 tokens</li><li>mean: 197.43 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1602webquestionquestion_genreation

—Dataset: task1602webquestionquestion_genreation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 12 tokens</li><li>mean: 23.58 tokens</li><li>max: 112 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 24.11 tokens</li><li>max: 112 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 22.62 tokens</li><li>max: 120 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task747glucosecauseemotiondetection

—Dataset: task747glucosecauseemotiondetection
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 35 tokens</li><li>mean: 67.98 tokens</li><li>max: 112 tokens</li></ul> | <ul><li>min: 36 tokens</li><li>mean: 68.1 tokens</li><li>max: 108 tokens</li></ul> | <ul><li>min: 36 tokens</li><li>mean: 68.61 tokens</li><li>max: 99 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task219rocstoriestitleanswergeneration

—Dataset: task219rocstoriestitleanswergeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 42 tokens</li><li>mean: 67.46 tokens</li><li>max: 97 tokens</li></ul> | <ul><li>min: 45 tokens</li><li>mean: 66.69 tokens</li><li>max: 97 tokens</li></ul> | <ul><li>min: 41 tokens</li><li>mean: 66.66 tokens</li><li>max: 96 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task178quartzquestion_answering

—Dataset: task178quartzquestion_answering
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 28 tokens</li><li>mean: 58.01 tokens</li><li>max: 110 tokens</li></ul> | <ul><li>min: 28 tokens</li><li>mean: 57.24 tokens</li><li>max: 111 tokens</li></ul> | <ul><li>min: 28 tokens</li><li>mean: 56.88 tokens</li><li>max: 102 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task103facts2storylongtextgeneration

—Dataset: task103facts2storylongtextgeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 52 tokens</li><li>mean: 80.34 tokens</li><li>max: 143 tokens</li></ul> | <ul><li>min: 51 tokens</li><li>mean: 82.25 tokens</li><li>max: 157 tokens</li></ul> | <ul><li>min: 49 tokens</li><li>mean: 78.89 tokens</li><li>max: 145 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task301recordquestion_generation

—Dataset: task301recordquestion_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 140 tokens</li><li>mean: 210.86 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 139 tokens</li><li>mean: 209.77 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 143 tokens</li><li>mean: 208.82 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1369healthfactsentence_generation

—Dataset: task1369healthfactsentence_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 110 tokens</li><li>mean: 243.2 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 101 tokens</li><li>mean: 242.83 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 113 tokens</li><li>mean: 251.68 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task515sentevaloddwordout

—Dataset: task515sentevaloddwordout
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 7 tokens</li><li>mean: 19.75 tokens</li><li>max: 36 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 19.09 tokens</li><li>max: 38 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 19.03 tokens</li><li>max: 35 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task496semevalanswer_generation

—Dataset: task496semevalanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 4 tokens</li><li>mean: 28.14 tokens</li><li>max: 46 tokens</li></ul> | <ul><li>min: 18 tokens</li><li>mean: 27.82 tokens</li><li>max: 45 tokens</li></ul> | <ul><li>min: 19 tokens</li><li>mean: 27.7 tokens</li><li>max: 45 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1658billsumsummarization

—Dataset: task1658billsumsummarization
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 256 tokens</li><li>mean: 256.0 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 256 tokens</li><li>mean: 256.0 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 256 tokens</li><li>mean: 256.0 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1204atomicclassification_hinderedby

—Dataset: task1204atomicclassification_hinderedby
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 14 tokens</li><li>mean: 21.99 tokens</li><li>max: 35 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 21.93 tokens</li><li>max: 34 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 21.51 tokens</li><li>max: 38 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1392supergluemultircanswerverification

—Dataset: task1392supergluemultircanswerverification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 128 tokens</li><li>mean: 242.14 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 127 tokens</li><li>mean: 242.38 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 136 tokens</li><li>mean: 242.41 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task306jeopardyanswergenerationdouble

—Dataset: task306jeopardyanswergenerationdouble
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 10 tokens</li><li>mean: 27.69 tokens</li><li>max: 47 tokens</li></ul> | <ul><li>min: 10 tokens</li><li>mean: 27.18 tokens</li><li>max: 46 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 27.69 tokens</li><li>max: 47 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1286openbookqaquestion_answering

—Dataset: task1286openbookqaquestion_answering
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 22 tokens</li><li>mean: 39.58 tokens</li><li>max: 85 tokens</li></ul> | <ul><li>min: 23 tokens</li><li>mean: 38.97 tokens</li><li>max: 96 tokens</li></ul> | <ul><li>min: 22 tokens</li><li>mean: 38.38 tokens</li><li>max: 89 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task159checkfrequencyofwordsinsentence_pair

—Dataset: task159checkfrequencyofwordsinsentence_pair
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 44 tokens</li><li>mean: 50.32 tokens</li><li>max: 67 tokens</li></ul> | <ul><li>min: 44 tokens</li><li>mean: 50.32 tokens</li><li>max: 67 tokens</li></ul> | <ul><li>min: 44 tokens</li><li>mean: 50.55 tokens</li><li>max: 66 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task151tomqafindlocationeasy_clean

—Dataset: task151tomqafindlocationeasy_clean
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 37 tokens</li><li>mean: 50.71 tokens</li><li>max: 79 tokens</li></ul> | <ul><li>min: 37 tokens</li><li>mean: 50.34 tokens</li><li>max: 74 tokens</li></ul> | <ul><li>min: 37 tokens</li><li>mean: 50.55 tokens</li><li>max: 74 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task323jigsawclassificationsexuallyexplicit

—Dataset: task323jigsawclassificationsexuallyexplicit
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 6 tokens</li><li>mean: 66.2 tokens</li><li>max: 248 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 76.88 tokens</li><li>max: 248 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 75.63 tokens</li><li>max: 251 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task037qascgeneraterelatedfact

—Dataset: task037qascgeneraterelatedfact
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 13 tokens</li><li>mean: 22.08 tokens</li><li>max: 50 tokens</li></ul> | <ul><li>min: 13 tokens</li><li>mean: 22.07 tokens</li><li>max: 42 tokens</li></ul> | <ul><li>min: 13 tokens</li><li>mean: 21.86 tokens</li><li>max: 40 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task027dropanswertypegeneration

—Dataset: task027dropanswertypegeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 87 tokens</li><li>mean: 229.57 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 74 tokens</li><li>mean: 230.76 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 71 tokens</li><li>mean: 233.03 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1596event2mindtextgeneration2

—Dataset: task1596event2mindtextgeneration2
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 6 tokens</li><li>mean: 10.01 tokens</li><li>max: 18 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 10.03 tokens</li><li>max: 19 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 10.05 tokens</li><li>max: 18 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task141odd-man-outclassification_category

—Dataset: task141odd-man-outclassification_category
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 16 tokens</li><li>mean: 18.44 tokens</li><li>max: 28 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 18.37 tokens</li><li>max: 26 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 18.47 tokens</li><li>max: 25 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task194duorcanswer_generation

—Dataset: task194duorcanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 149 tokens</li><li>mean: 251.63 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 147 tokens</li><li>mean: 251.92 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 148 tokens</li><li>mean: 251.62 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task679hopeedienglishtext_classification

—Dataset: task679hopeedienglishtext_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 5 tokens</li><li>mean: 27.45 tokens</li><li>max: 199 tokens</li></ul> | <ul><li>min: 4 tokens</li><li>mean: 26.89 tokens</li><li>max: 205 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 29.73 tokens</li><li>max: 194 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task246dreamquestion_generation

—Dataset: task246dreamquestion_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 17 tokens</li><li>mean: 80.75 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 82.01 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 15 tokens</li><li>mean: 88.35 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1195disflqadisfluenttofluent_conversion

—Dataset: task1195disflqadisfluenttofluent_conversion
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 9 tokens</li><li>mean: 19.82 tokens</li><li>max: 41 tokens</li></ul> | <ul><li>min: 9 tokens</li><li>mean: 19.85 tokens</li><li>max: 40 tokens</li></ul> | <ul><li>min: 2 tokens</li><li>mean: 20.01 tokens</li><li>max: 44 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task065timetravelconsistentsentenceclassification

—Dataset: task065timetravelconsistentsentenceclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 55 tokens</li><li>mean: 79.35 tokens</li><li>max: 117 tokens</li></ul> | <ul><li>min: 51 tokens</li><li>mean: 79.17 tokens</li><li>max: 110 tokens</li></ul> | <ul><li>min: 53 tokens</li><li>mean: 80.01 tokens</li><li>max: 110 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task351winomtclassificationgenderidentifiability_anti

—Dataset: task351winomtclassificationgenderidentifiability_anti
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 16 tokens</li><li>mean: 21.77 tokens</li><li>max: 30 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 21.68 tokens</li><li>max: 31 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 21.8 tokens</li><li>max: 30 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task580socialiqaanswer_generation

—Dataset: task580socialiqaanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 35 tokens</li><li>mean: 52.38 tokens</li><li>max: 107 tokens</li></ul> | <ul><li>min: 35 tokens</li><li>mean: 50.97 tokens</li><li>max: 86 tokens</li></ul> | <ul><li>min: 35 tokens</li><li>mean: 50.98 tokens</li><li>max: 87 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task583udepsengcoarsepos_tagging

—Dataset: task583udepsengcoarsepos_tagging
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 12 tokens</li><li>mean: 41.24 tokens</li><li>max: 185 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 40.17 tokens</li><li>max: 185 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 40.93 tokens</li><li>max: 185 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task202mnlicontradiction_classification

—Dataset: task202mnlicontradiction_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 24 tokens</li><li>mean: 73.97 tokens</li><li>max: 190 tokens</li></ul> | <ul><li>min: 28 tokens</li><li>mean: 76.45 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 23 tokens</li><li>mean: 74.52 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task222rocstoriestwochioceslotting_classification

—Dataset: task222rocstoriestwochioceslotting_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 48 tokens</li><li>mean: 73.12 tokens</li><li>max: 105 tokens</li></ul> | <ul><li>min: 48 tokens</li><li>mean: 73.22 tokens</li><li>max: 100 tokens</li></ul> | <ul><li>min: 49 tokens</li><li>mean: 71.79 tokens</li><li>max: 102 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task498scruplesanecdoteswhoiswrongclassification

—Dataset: task498scruplesanecdoteswhoiswrongclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 24 tokens</li><li>mean: 225.54 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 47 tokens</li><li>mean: 232.42 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 47 tokens</li><li>mean: 231.37 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task067abductivenlianswer_generation

—Dataset: task067abductivenlianswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 14 tokens</li><li>mean: 26.74 tokens</li><li>max: 40 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 26.11 tokens</li><li>max: 42 tokens</li></ul> | <ul><li>min: 15 tokens</li><li>mean: 26.32 tokens</li><li>max: 38 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task616colaclassification

—Dataset: task616colaclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 5 tokens</li><li>mean: 12.04 tokens</li><li>max: 33 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 11.89 tokens</li><li>max: 33 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 11.78 tokens</li><li>max: 29 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task286olidoffense_judgment

—Dataset: task286olidoffense_judgment
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 5 tokens</li><li>mean: 32.66 tokens</li><li>max: 145 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 30.9 tokens</li><li>max: 171 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 30.45 tokens</li><li>max: 169 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task188snlineutraltoentailmenttextmodification

—Dataset: task188snlineutraltoentailmenttextmodification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 18 tokens</li><li>mean: 31.62 tokens</li><li>max: 79 tokens</li></ul> | <ul><li>min: 18 tokens</li><li>mean: 31.27 tokens</li><li>max: 84 tokens</li></ul> | <ul><li>min: 18 tokens</li><li>mean: 32.91 tokens</li><li>max: 84 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task223quartzexplanation_generation

—Dataset: task223quartzexplanation_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 12 tokens</li><li>mean: 31.44 tokens</li><li>max: 68 tokens</li></ul> | <ul><li>min: 13 tokens</li><li>mean: 31.81 tokens</li><li>max: 68 tokens</li></ul> | <ul><li>min: 13 tokens</li><li>mean: 28.95 tokens</li><li>max: 96 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task820protoqaanswer_generation

—Dataset: task820protoqaanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 6 tokens</li><li>mean: 14.78 tokens</li><li>max: 29 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 14.48 tokens</li><li>max: 27 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 14.16 tokens</li><li>max: 29 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task196sentiment140answer_generation

—Dataset: task196sentiment140answer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 17 tokens</li><li>mean: 36.17 tokens</li><li>max: 72 tokens</li></ul> | <ul><li>min: 17 tokens</li><li>mean: 32.79 tokens</li><li>max: 61 tokens</li></ul> | <ul><li>min: 17 tokens</li><li>mean: 36.17 tokens</li><li>max: 72 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1678mathqaanswer_selection

—Dataset: task1678mathqaanswer_selection
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 33 tokens</li><li>mean: 70.07 tokens</li><li>max: 177 tokens</li></ul> | <ul><li>min: 30 tokens</li><li>mean: 68.83 tokens</li><li>max: 146 tokens</li></ul> | <ul><li>min: 33 tokens</li><li>mean: 69.25 tokens</li><li>max: 160 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task349squad2.0answerableunanswerablequestion_classification

—Dataset: task349squad2.0answerableunanswerablequestion_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 53 tokens</li><li>mean: 175.42 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 57 tokens</li><li>mean: 175.64 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 53 tokens</li><li>mean: 175.46 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task154tomqafindlocationhard_noise

—Dataset: task154tomqafindlocationhard_noise
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 129 tokens</li><li>mean: 176.06 tokens</li><li>max: 253 tokens</li></ul> | <ul><li>min: 126 tokens</li><li>mean: 176.19 tokens</li><li>max: 249 tokens</li></ul> | <ul><li>min: 128 tokens</li><li>mean: 178.05 tokens</li><li>max: 254 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task333hateevalclassificationhateen

—Dataset: task333hateevalclassificationhateen
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 8 tokens</li><li>mean: 38.52 tokens</li><li>max: 117 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 37.54 tokens</li><li>max: 109 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 36.61 tokens</li><li>max: 113 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task235iircquestionfromsubtextanswergeneration

—Dataset: task235iircquestionfromsubtextanswergeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 14 tokens</li><li>mean: 52.65 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 50.81 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 55.42 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1554scitailclassification

—Dataset: task1554scitailclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 7 tokens</li><li>mean: 16.71 tokens</li><li>max: 38 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 25.82 tokens</li><li>max: 68 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 24.36 tokens</li><li>max: 59 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task210logic2textstructuredtextgeneration

—Dataset: task210logic2textstructuredtextgeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 13 tokens</li><li>mean: 31.69 tokens</li><li>max: 101 tokens</li></ul> | <ul><li>min: 13 tokens</li><li>mean: 30.77 tokens</li><li>max: 94 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 32.84 tokens</li><li>max: 89 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task035winograndequestionmodificationperson

—Dataset: task035winograndequestionmodificationperson
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 31 tokens</li><li>mean: 36.16 tokens</li><li>max: 50 tokens</li></ul> | <ul><li>min: 31 tokens</li><li>mean: 35.76 tokens</li><li>max: 55 tokens</li></ul> | <ul><li>min: 31 tokens</li><li>mean: 35.45 tokens</li><li>max: 48 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task230iircpassage_classification

—Dataset: task230iircpassage_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 256 tokens</li><li>mean: 256.0 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 256 tokens</li><li>mean: 256.0 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 256 tokens</li><li>mean: 256.0 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1356xlsumtitle_generation

—Dataset: task1356xlsumtitle_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 59 tokens</li><li>mean: 239.68 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 58 tokens</li><li>mean: 240.91 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 64 tokens</li><li>mean: 248.66 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1726mathqacorrectanswergeneration

—Dataset: task1726mathqacorrectanswergeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 10 tokens</li><li>mean: 43.56 tokens</li><li>max: 156 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 42.33 tokens</li><li>max: 129 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 42.65 tokens</li><li>max: 133 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task302recordclassification

—Dataset: task302recordclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 194 tokens</li><li>mean: 253.58 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 198 tokens</li><li>mean: 253.06 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 195 tokens</li><li>mean: 253.03 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task380boolqyesnoquestion

—Dataset: task380boolqyesnoquestion
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 26 tokens</li><li>mean: 133.31 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 26 tokens</li><li>mean: 138.46 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 27 tokens</li><li>mean: 136.88 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task212logic2textclassification

—Dataset: task212logic2textclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 14 tokens</li><li>mean: 33.11 tokens</li><li>max: 146 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 31.93 tokens</li><li>max: 146 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 32.81 tokens</li><li>max: 127 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task748glucosereversecauseevent_detection

—Dataset: task748glucosereversecauseevent_detection
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 35 tokens</li><li>mean: 67.61 tokens</li><li>max: 105 tokens</li></ul> | <ul><li>min: 38 tokens</li><li>mean: 66.97 tokens</li><li>max: 106 tokens</li></ul> | <ul><li>min: 39 tokens</li><li>mean: 68.92 tokens</li><li>max: 105 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task834mathdatasetclassification

—Dataset: task834mathdatasetclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:---------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 6 tokens</li><li>mean: 27.8 tokens</li><li>max: 83 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 28.03 tokens</li><li>max: 83 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 27.13 tokens</li><li>max: 93 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task350winomtclassificationgenderidentifiability_pro

—Dataset: task350winomtclassificationgenderidentifiability_pro
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 16 tokens</li><li>mean: 21.83 tokens</li><li>max: 30 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 21.66 tokens</li><li>max: 30 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 21.82 tokens</li><li>max: 30 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task191hotpotqaquestion_generation

—Dataset: task191hotpotqaquestion_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 198 tokens</li><li>mean: 255.94 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 238 tokens</li><li>mean: 255.96 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 255 tokens</li><li>mean: 256.0 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task236iircquestionfrompassageanswergeneration

—Dataset: task236iircquestionfrompassageanswergeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 135 tokens</li><li>mean: 238.59 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 155 tokens</li><li>mean: 237.63 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 154 tokens</li><li>mean: 239.46 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task217rocstoriesorderinganswergeneration

—Dataset: task217rocstoriesorderinganswergeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 45 tokens</li><li>mean: 72.31 tokens</li><li>max: 107 tokens</li></ul> | <ul><li>min: 48 tokens</li><li>mean: 72.27 tokens</li><li>max: 107 tokens</li></ul> | <ul><li>min: 48 tokens</li><li>mean: 70.82 tokens</li><li>max: 105 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task568circaquestion_generation

—Dataset: task568circaquestion_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:--------------------------------------------------------------------------------|:---------------------------------------------------------------------------------|:---------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 4 tokens</li><li>mean: 9.6 tokens</li><li>max: 25 tokens</li></ul> | <ul><li>min: 4 tokens</li><li>mean: 9.54 tokens</li><li>max: 20 tokens</li></ul> | <ul><li>min: 4 tokens</li><li>mean: 8.94 tokens</li><li>max: 20 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task614glucosecauseeventdetection

—Dataset: task614glucosecauseeventdetection
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 39 tokens</li><li>mean: 67.62 tokens</li><li>max: 102 tokens</li></ul> | <ul><li>min: 39 tokens</li><li>mean: 67.15 tokens</li><li>max: 106 tokens</li></ul> | <ul><li>min: 38 tokens</li><li>mean: 68.52 tokens</li><li>max: 103 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task361spolinyesandpromptresponse_classification

—Dataset: task361spolinyesandpromptresponse_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 18 tokens</li><li>mean: 46.94 tokens</li><li>max: 137 tokens</li></ul> | <ul><li>min: 17 tokens</li><li>mean: 45.9 tokens</li><li>max: 119 tokens</li></ul> | <ul><li>min: 17 tokens</li><li>mean: 47.09 tokens</li><li>max: 128 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task421persentsentencesentimentclassification

—Dataset: task421persentsentencesentimentclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 22 tokens</li><li>mean: 67.97 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 22 tokens</li><li>mean: 71.17 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 19 tokens</li><li>mean: 73.46 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task203mnlisentence_generation

—Dataset: task203mnlisentence_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 14 tokens</li><li>mean: 38.53 tokens</li><li>max: 175 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 35.45 tokens</li><li>max: 175 tokens</li></ul> | <ul><li>min: 13 tokens</li><li>mean: 34.01 tokens</li><li>max: 170 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task420persentdocumentsentimentclassification

—Dataset: task420persentdocumentsentimentclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 22 tokens</li><li>mean: 224.65 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 22 tokens</li><li>mean: 233.63 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 22 tokens</li><li>mean: 227.77 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task153tomqafindlocationhard_clean

—Dataset: task153tomqafindlocationhard_clean
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 39 tokens</li><li>mean: 160.59 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 39 tokens</li><li>mean: 160.47 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 39 tokens</li><li>mean: 163.65 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task346hybridqaclassification

—Dataset: task346hybridqaclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 18 tokens</li><li>mean: 32.87 tokens</li><li>max: 68 tokens</li></ul> | <ul><li>min: 18 tokens</li><li>mean: 31.94 tokens</li><li>max: 63 tokens</li></ul> | <ul><li>min: 19 tokens</li><li>mean: 31.86 tokens</li><li>max: 75 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1211atomicclassification_hassubevent

—Dataset: task1211atomicclassification_hassubevent
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 11 tokens</li><li>mean: 16.28 tokens</li><li>max: 31 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 16.09 tokens</li><li>max: 29 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 16.82 tokens</li><li>max: 29 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task360spolinyesandresponsegeneration

—Dataset: task360spolinyesandresponsegeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 7 tokens</li><li>mean: 22.55 tokens</li><li>max: 89 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 21.08 tokens</li><li>max: 92 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 20.53 tokens</li><li>max: 67 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task510reddittifutitlesummarization

—Dataset: task510reddittifutitlesummarization
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 9 tokens</li><li>mean: 217.61 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 20 tokens</li><li>mean: 218.05 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 10 tokens</li><li>mean: 222.01 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task511reddittifulongtext_summarization

—Dataset: task511reddittifulongtext_summarization
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 29 tokens</li><li>mean: 239.33 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 76 tokens</li><li>mean: 239.31 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 43 tokens</li><li>mean: 245.31 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task345hybridqaanswer_generation

—Dataset: task345hybridqaanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 9 tokens</li><li>mean: 22.15 tokens</li><li>max: 50 tokens</li></ul> | <ul><li>min: 10 tokens</li><li>mean: 21.61 tokens</li><li>max: 70 tokens</li></ul> | <ul><li>min: 8 tokens</li><li>mean: 20.95 tokens</li><li>max: 47 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task270csrgcounterfactualcontextgeneration

—Dataset: task270csrgcounterfactualcontextgeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 63 tokens</li><li>mean: 100.11 tokens</li><li>max: 158 tokens</li></ul> | <ul><li>min: 63 tokens</li><li>mean: 98.64 tokens</li><li>max: 142 tokens</li></ul> | <ul><li>min: 62 tokens</li><li>mean: 100.38 tokens</li><li>max: 141 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task307jeopardyanswergenerationfinal

—Dataset: task307jeopardyanswergenerationfinal
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 15 tokens</li><li>mean: 29.57 tokens</li><li>max: 46 tokens</li></ul> | <ul><li>min: 15 tokens</li><li>mean: 29.28 tokens</li><li>max: 53 tokens</li></ul> | <ul><li>min: 15 tokens</li><li>mean: 29.16 tokens</li><li>max: 43 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task001quorefquestion_generation

—Dataset: task001quorefquestion_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:--------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 201 tokens</li><li>mean: 255.03 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 99 tokens</li><li>mean: 254.28 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 173 tokens</li><li>mean: 255.16 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task089swapwords_verification

—Dataset: task089swapwords_verification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 9 tokens</li><li>mean: 12.88 tokens</li><li>max: 28 tokens</li></ul> | <ul><li>min: 9 tokens</li><li>mean: 12.64 tokens</li><li>max: 24 tokens</li></ul> | <ul><li>min: 9 tokens</li><li>mean: 12.25 tokens</li><li>max: 22 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1196atomicclassification_oeffect

—Dataset: task1196atomicclassification_oeffect
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 14 tokens</li><li>mean: 18.83 tokens</li><li>max: 41 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 18.6 tokens</li><li>max: 30 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 18.52 tokens</li><li>max: 29 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task080piqaanswer_generation

—Dataset: task080piqaanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 3 tokens</li><li>mean: 10.86 tokens</li><li>max: 33 tokens</li></ul> | <ul><li>min: 3 tokens</li><li>mean: 10.75 tokens</li><li>max: 24 tokens</li></ul> | <ul><li>min: 3 tokens</li><li>mean: 10.13 tokens</li><li>max: 26 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1598nyclongtextgeneration

—Dataset: task1598nyclongtextgeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 17 tokens</li><li>mean: 35.49 tokens</li><li>max: 56 tokens</li></ul> | <ul><li>min: 17 tokens</li><li>mean: 35.67 tokens</li><li>max: 56 tokens</li></ul> | <ul><li>min: 20 tokens</li><li>mean: 36.67 tokens</li><li>max: 55 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task240tweetqaquestion_generation

—Dataset: task240tweetqaquestion_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 27 tokens</li><li>mean: 51.08 tokens</li><li>max: 94 tokens</li></ul> | <ul><li>min: 25 tokens</li><li>mean: 50.77 tokens</li><li>max: 92 tokens</li></ul> | <ul><li>min: 20 tokens</li><li>mean: 51.62 tokens</li><li>max: 95 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task615moviesqaanswer_generation

—Dataset: task615moviesqaanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 6 tokens</li><li>mean: 11.45 tokens</li><li>max: 23 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 11.45 tokens</li><li>max: 19 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 11.38 tokens</li><li>max: 22 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1347gluests-bsimilarityclassification

—Dataset: task1347gluests-bsimilarityclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 17 tokens</li><li>mean: 31.24 tokens</li><li>max: 88 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 31.2 tokens</li><li>max: 92 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 31.09 tokens</li><li>max: 92 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task114isthegivenword_longest

—Dataset: task114isthegivenword_longest
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 25 tokens</li><li>mean: 28.89 tokens</li><li>max: 68 tokens</li></ul> | <ul><li>min: 25 tokens</li><li>mean: 28.47 tokens</li><li>max: 48 tokens</li></ul> | <ul><li>min: 25 tokens</li><li>mean: 28.72 tokens</li><li>max: 47 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task292storycommonsensecharactertextgeneration

—Dataset: task292storycommonsensecharactertextgeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 43 tokens</li><li>mean: 67.71 tokens</li><li>max: 98 tokens</li></ul> | <ul><li>min: 46 tokens</li><li>mean: 67.07 tokens</li><li>max: 104 tokens</li></ul> | <ul><li>min: 43 tokens</li><li>mean: 69.02 tokens</li><li>max: 96 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task115helpadvice_classification

—Dataset: task115helpadvice_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:---------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 2 tokens</li><li>mean: 19.87 tokens</li><li>max: 91 tokens</li></ul> | <ul><li>min: 3 tokens</li><li>mean: 18.3 tokens</li><li>max: 92 tokens</li></ul> | <ul><li>min: 4 tokens</li><li>mean: 19.29 tokens</li><li>max: 137 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task431sentevalobject_count

—Dataset: task431sentevalobject_count
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:---------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 7 tokens</li><li>mean: 16.7 tokens</li><li>max: 37 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 15.14 tokens</li><li>max: 36 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 15.77 tokens</li><li>max: 35 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1360numersensemultiplechoiceqageneration

—Dataset: task1360numersensemultiplechoiceqageneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 32 tokens</li><li>mean: 40.56 tokens</li><li>max: 54 tokens</li></ul> | <ul><li>min: 32 tokens</li><li>mean: 40.29 tokens</li><li>max: 53 tokens</li></ul> | <ul><li>min: 32 tokens</li><li>mean: 40.18 tokens</li><li>max: 60 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task177para-nmtparaphrasing

—Dataset: task177para-nmtparaphrasing
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 8 tokens</li><li>mean: 19.87 tokens</li><li>max: 82 tokens</li></ul> | <ul><li>min: 9 tokens</li><li>mean: 18.96 tokens</li><li>max: 58 tokens</li></ul> | <ul><li>min: 9 tokens</li><li>mean: 18.19 tokens</li><li>max: 36 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task132daistext_modification

—Dataset: task132daistext_modification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:---------------------------------------------------------------------------------|:---------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 6 tokens</li><li>mean: 9.32 tokens</li><li>max: 15 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 9.06 tokens</li><li>max: 15 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 10.15 tokens</li><li>max: 15 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task269csrgcounterfactualstorygeneration

—Dataset: task269csrgcounterfactualstorygeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 49 tokens</li><li>mean: 79.95 tokens</li><li>max: 111 tokens</li></ul> | <ul><li>min: 53 tokens</li><li>mean: 79.59 tokens</li><li>max: 116 tokens</li></ul> | <ul><li>min: 48 tokens</li><li>mean: 79.46 tokens</li><li>max: 114 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task233iirclinkexistsclassification

—Dataset: task233iirclinkexistsclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:--------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 145 tokens</li><li>mean: 235.57 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 142 tokens</li><li>mean: 233.4 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 151 tokens</li><li>mean: 235.09 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task161countwordscontainingletter

—Dataset: task161countwordscontainingletter
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 27 tokens</li><li>mean: 30.98 tokens</li><li>max: 53 tokens</li></ul> | <ul><li>min: 27 tokens</li><li>mean: 30.8 tokens</li><li>max: 61 tokens</li></ul> | <ul><li>min: 27 tokens</li><li>mean: 30.49 tokens</li><li>max: 42 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1205atomicclassification_isafter

—Dataset: task1205atomicclassification_isafter
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 14 tokens</li><li>mean: 20.94 tokens</li><li>max: 37 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 20.67 tokens</li><li>max: 35 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 21.53 tokens</li><li>max: 37 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task571recipenlgnergeneration

—Dataset: task571recipenlgnergeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 5 tokens</li><li>mean: 117.85 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 118.49 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 110.67 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1292yelpreviewfulltext_categorization

—Dataset: task1292yelpreviewfulltext_categorization
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 4 tokens</li><li>mean: 136.64 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 145.86 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 3 tokens</li><li>mean: 146.28 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task428sentevalinversion

—Dataset: task428sentevalinversion
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 7 tokens</li><li>mean: 16.73 tokens</li><li>max: 32 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 14.59 tokens</li><li>max: 31 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 15.29 tokens</li><li>max: 34 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task311racequestion_generation

—Dataset: task311racequestion_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 115 tokens</li><li>mean: 254.46 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 137 tokens</li><li>mean: 254.27 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 171 tokens</li><li>mean: 255.43 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task429sentevaltense

—Dataset: task429sentevaltense
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 7 tokens</li><li>mean: 15.84 tokens</li><li>max: 37 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 14.09 tokens</li><li>max: 33 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 15.26 tokens</li><li>max: 36 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task403creakcommonsense_inference

—Dataset: task403creakcommonsense_inference
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 13 tokens</li><li>mean: 30.18 tokens</li><li>max: 104 tokens</li></ul> | <ul><li>min: 13 tokens</li><li>mean: 29.39 tokens</li><li>max: 108 tokens</li></ul> | <ul><li>min: 13 tokens</li><li>mean: 29.38 tokens</li><li>max: 122 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task929productsreviews_classification

—Dataset: task929productsreviews_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 5 tokens</li><li>mean: 69.24 tokens</li><li>max: 126 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 70.37 tokens</li><li>max: 123 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 69.81 tokens</li><li>max: 123 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task582naturalquestionanswer_generation

—Dataset: task582naturalquestionanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 10 tokens</li><li>mean: 11.7 tokens</li><li>max: 25 tokens</li></ul> | <ul><li>min: 10 tokens</li><li>mean: 11.63 tokens</li><li>max: 24 tokens</li></ul> | <ul><li>min: 10 tokens</li><li>mean: 11.71 tokens</li><li>max: 25 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task237iircanswerfromsubtextanswergeneration

—Dataset: task237iircanswerfromsubtextanswergeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 22 tokens</li><li>mean: 66.05 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 25 tokens</li><li>mean: 64.68 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 23 tokens</li><li>mean: 61.38 tokens</li><li>max: 161 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task050multircanswerability

—Dataset: task050multircanswerability
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 15 tokens</li><li>mean: 32.33 tokens</li><li>max: 112 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 31.67 tokens</li><li>max: 93 tokens</li></ul> | <ul><li>min: 15 tokens</li><li>mean: 32.1 tokens</li><li>max: 159 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task184breakgenerate_question

—Dataset: task184breakgenerate_question
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 13 tokens</li><li>mean: 39.79 tokens</li><li>max: 147 tokens</li></ul> | <ul><li>min: 13 tokens</li><li>mean: 39.17 tokens</li><li>max: 149 tokens</li></ul> | <ul><li>min: 13 tokens</li><li>mean: 39.76 tokens</li><li>max: 148 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task669ambigqaanswer_generation

—Dataset: task669ambigqaanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 10 tokens</li><li>mean: 12.91 tokens</li><li>max: 23 tokens</li></ul> | <ul><li>min: 10 tokens</li><li>mean: 12.84 tokens</li><li>max: 27 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 12.77 tokens</li><li>max: 22 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task169strategyqasentence_generation

—Dataset: task169strategyqasentence_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 19 tokens</li><li>mean: 35.06 tokens</li><li>max: 65 tokens</li></ul> | <ul><li>min: 22 tokens</li><li>mean: 34.24 tokens</li><li>max: 60 tokens</li></ul> | <ul><li>min: 19 tokens</li><li>mean: 33.39 tokens</li><li>max: 65 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task500scruplesanecdotestitlegeneration

—Dataset: task500scruplesanecdotestitlegeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 14 tokens</li><li>mean: 225.39 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 31 tokens</li><li>mean: 233.58 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 27 tokens</li><li>mean: 235.29 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task241tweetqaclassification

—Dataset: task241tweetqaclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 31 tokens</li><li>mean: 61.8 tokens</li><li>max: 92 tokens</li></ul> | <ul><li>min: 36 tokens</li><li>mean: 62.26 tokens</li><li>max: 106 tokens</li></ul> | <ul><li>min: 31 tokens</li><li>mean: 61.75 tokens</li><li>max: 92 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1345glueqqpquestionparaprashing

—Dataset: task1345glueqqpquestionparaprashing
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 6 tokens</li><li>mean: 16.68 tokens</li><li>max: 60 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 15.76 tokens</li><li>max: 69 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 16.66 tokens</li><li>max: 51 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task218rocstoriesswaporderanswer_generation

—Dataset: task218rocstoriesswaporderanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 48 tokens</li><li>mean: 72.49 tokens</li><li>max: 118 tokens</li></ul> | <ul><li>min: 48 tokens</li><li>mean: 72.41 tokens</li><li>max: 102 tokens</li></ul> | <ul><li>min: 47 tokens</li><li>mean: 72.0 tokens</li><li>max: 106 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task613politifacttext_generation

—Dataset: task613politifacttext_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 4 tokens</li><li>mean: 24.91 tokens</li><li>max: 75 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 23.45 tokens</li><li>max: 56 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 23.08 tokens</li><li>max: 61 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1167penntreebankcoarsepos_tagging

—Dataset: task1167penntreebankcoarsepos_tagging
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 16 tokens</li><li>mean: 53.76 tokens</li><li>max: 200 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 53.51 tokens</li><li>max: 220 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 55.01 tokens</li><li>max: 202 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1422mathqaphysics

—Dataset: task1422mathqaphysics
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 34 tokens</li><li>mean: 72.54 tokens</li><li>max: 164 tokens</li></ul> | <ul><li>min: 38 tokens</li><li>mean: 71.69 tokens</li><li>max: 157 tokens</li></ul> | <ul><li>min: 39 tokens</li><li>mean: 72.52 tokens</li><li>max: 155 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task247dreamanswer_generation

—Dataset: task247dreamanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 38 tokens</li><li>mean: 159.84 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 39 tokens</li><li>mean: 159.0 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 41 tokens</li><li>mean: 167.81 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task199mnliclassification

—Dataset: task199mnliclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 13 tokens</li><li>mean: 43.05 tokens</li><li>max: 127 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 44.81 tokens</li><li>max: 149 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 43.76 tokens</li><li>max: 113 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task164mcscriptquestionansweringtext

—Dataset: task164mcscriptquestionansweringtext
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 150 tokens</li><li>mean: 200.04 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 150 tokens</li><li>mean: 200.14 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 142 tokens</li><li>mean: 200.45 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1541agnewsclassification

—Dataset: task1541agnewsclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 21 tokens</li><li>mean: 53.59 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 18 tokens</li><li>mean: 53.06 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 18 tokens</li><li>mean: 53.85 tokens</li><li>max: 161 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task516sentevalconjoints_inversion

—Dataset: task516sentevalconjoints_inversion
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 8 tokens</li><li>mean: 20.19 tokens</li><li>max: 34 tokens</li></ul> | <ul><li>min: 8 tokens</li><li>mean: 19.08 tokens</li><li>max: 34 tokens</li></ul> | <ul><li>min: 8 tokens</li><li>mean: 18.91 tokens</li><li>max: 34 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task294storycommonsensemotivtextgeneration

—Dataset: task294storycommonsensemotivtextgeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 14 tokens</li><li>mean: 40.11 tokens</li><li>max: 86 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 40.64 tokens</li><li>max: 86 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 39.84 tokens</li><li>max: 86 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task501scruplesanecdotesposttype_verification

—Dataset: task501scruplesanecdotesposttype_verification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 18 tokens</li><li>mean: 231.21 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 235.17 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 18 tokens</li><li>mean: 234.22 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task213rocstoriescorrectendingclassification

—Dataset: task213rocstoriescorrectendingclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 62 tokens</li><li>mean: 86.15 tokens</li><li>max: 125 tokens</li></ul> | <ul><li>min: 60 tokens</li><li>mean: 85.55 tokens</li><li>max: 131 tokens</li></ul> | <ul><li>min: 59 tokens</li><li>mean: 85.87 tokens</li><li>max: 131 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task821protoqaquestion_generation

—Dataset: task821protoqaquestion_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 5 tokens</li><li>mean: 14.94 tokens</li><li>max: 61 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 14.99 tokens</li><li>max: 35 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 13.94 tokens</li><li>max: 93 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task493reviewpolarity_classification

—Dataset: task493reviewpolarity_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 18 tokens</li><li>mean: 100.61 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 19 tokens</li><li>mean: 107.72 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 114.08 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task308jeopardyanswergenerationall

—Dataset: task308jeopardyanswergenerationall
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:---------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 12 tokens</li><li>mean: 27.93 tokens</li><li>max: 50 tokens</li></ul> | <ul><li>min: 10 tokens</li><li>mean: 27.02 tokens</li><li>max: 44 tokens</li></ul> | <ul><li>min: 9 tokens</li><li>mean: 27.4 tokens</li><li>max: 48 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1595event2mindtextgeneration1

—Dataset: task1595event2mindtextgeneration1
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:---------------------------------------------------------------------------------|:---------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 6 tokens</li><li>mean: 9.88 tokens</li><li>max: 18 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 9.95 tokens</li><li>max: 20 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 10.04 tokens</li><li>max: 20 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task040qascquestion_generation

—Dataset: task040qascquestion_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 8 tokens</li><li>mean: 15.06 tokens</li><li>max: 29 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 15.09 tokens</li><li>max: 30 tokens</li></ul> | <ul><li>min: 8 tokens</li><li>mean: 13.89 tokens</li><li>max: 32 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task231iirclink_classification

—Dataset: task231iirclink_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 179 tokens</li><li>mean: 246.06 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 170 tokens</li><li>mean: 246.23 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 161 tokens</li><li>mean: 247.22 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1727wiqawhatisthe_effect

—Dataset: task1727wiqawhatisthe_effect
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 44 tokens</li><li>mean: 95.82 tokens</li><li>max: 183 tokens</li></ul> | <ul><li>min: 44 tokens</li><li>mean: 95.96 tokens</li><li>max: 185 tokens</li></ul> | <ul><li>min: 43 tokens</li><li>mean: 96.16 tokens</li><li>max: 183 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task578curiositydialogsanswergeneration

—Dataset: task578curiositydialogsanswergeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 10 tokens</li><li>mean: 230.81 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 118 tokens</li><li>mean: 235.92 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 229.9 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task310raceclassification

—Dataset: task310raceclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:--------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 101 tokens</li><li>mean: 255.06 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 218 tokens</li><li>mean: 255.8 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 101 tokens</li><li>mean: 255.06 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task309raceanswer_generation

—Dataset: task309raceanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 75 tokens</li><li>mean: 255.0 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 204 tokens</li><li>mean: 255.57 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 75 tokens</li><li>mean: 255.16 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task379agnewstopic_classification

—Dataset: task379agnewstopic_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 20 tokens</li><li>mean: 54.55 tokens</li><li>max: 193 tokens</li></ul> | <ul><li>min: 20 tokens</li><li>mean: 54.45 tokens</li><li>max: 175 tokens</li></ul> | <ul><li>min: 21 tokens</li><li>mean: 54.58 tokens</li><li>max: 187 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task030winograndefull_person

—Dataset: task030winograndefull_person
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:---------------------------------------------------------------------------------|:--------------------------------------------------------------------------------|:---------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 7 tokens</li><li>mean: 7.61 tokens</li><li>max: 12 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 7.5 tokens</li><li>max: 12 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 7.37 tokens</li><li>max: 11 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1540parsedpdfs_summarization

—Dataset: task1540parsedpdfs_summarization
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 3 tokens</li><li>mean: 188.06 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 46 tokens</li><li>mean: 189.8 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 3 tokens</li><li>mean: 191.93 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task039qascfindoverlappingwords

—Dataset: task039qascfindoverlappingwords
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 16 tokens</li><li>mean: 30.53 tokens</li><li>max: 55 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 29.97 tokens</li><li>max: 57 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 30.64 tokens</li><li>max: 60 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1206atomicclassification_isbefore

—Dataset: task1206atomicclassification_isbefore
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 14 tokens</li><li>mean: 21.21 tokens</li><li>max: 40 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 20.82 tokens</li><li>max: 31 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 21.29 tokens</li><li>max: 31 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task157countvowelsandconsonants

—Dataset: task157countvowelsandconsonants
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 24 tokens</li><li>mean: 28.02 tokens</li><li>max: 41 tokens</li></ul> | <ul><li>min: 24 tokens</li><li>mean: 27.93 tokens</li><li>max: 41 tokens</li></ul> | <ul><li>min: 24 tokens</li><li>mean: 28.33 tokens</li><li>max: 39 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task339recordanswer_generation

—Dataset: task339recordanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 171 tokens</li><li>mean: 234.63 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 171 tokens</li><li>mean: 234.08 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 171 tokens</li><li>mean: 231.98 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task453swaganswer_generation

—Dataset: task453swaganswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 9 tokens</li><li>mean: 18.43 tokens</li><li>max: 60 tokens</li></ul> | <ul><li>min: 9 tokens</li><li>mean: 18.18 tokens</li><li>max: 63 tokens</li></ul> | <ul><li>min: 9 tokens</li><li>mean: 17.47 tokens</li><li>max: 55 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task848pubmedqaclassification

—Dataset: task848pubmedqaclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 21 tokens</li><li>mean: 249.37 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 21 tokens</li><li>mean: 250.34 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 84 tokens</li><li>mean: 251.85 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task673googlewellformedqueryclassification

—Dataset: task673googlewellformedqueryclassification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:---------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 6 tokens</li><li>mean: 11.58 tokens</li><li>max: 27 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 11.2 tokens</li><li>max: 24 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 11.33 tokens</li><li>max: 22 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task676ollierelationshipanswergeneration

—Dataset: task676ollierelationshipanswergeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 29 tokens</li><li>mean: 50.87 tokens</li><li>max: 113 tokens</li></ul> | <ul><li>min: 29 tokens</li><li>mean: 49.17 tokens</li><li>max: 134 tokens</li></ul> | <ul><li>min: 30 tokens</li><li>mean: 51.44 tokens</li><li>max: 113 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task268caseholdlegalanswergeneration

—Dataset: task268caseholdlegalanswergeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 235 tokens</li><li>mean: 255.94 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 156 tokens</li><li>mean: 255.46 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 226 tokens</li><li>mean: 255.94 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task844financialphrasebank_classification

—Dataset: task844financialphrasebank_classification
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 14 tokens</li><li>mean: 40.26 tokens</li><li>max: 86 tokens</li></ul> | <ul><li>min: 13 tokens</li><li>mean: 38.56 tokens</li><li>max: 78 tokens</li></ul> | <ul><li>min: 15 tokens</li><li>mean: 39.15 tokens</li><li>max: 86 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task330gapanswer_generation

—Dataset: task330gapanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 26 tokens</li><li>mean: 106.91 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 44 tokens</li><li>mean: 108.22 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 45 tokens</li><li>mean: 111.03 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task595mochaanswer_generation

—Dataset: task595mochaanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 44 tokens</li><li>mean: 94.19 tokens</li><li>max: 178 tokens</li></ul> | <ul><li>min: 21 tokens</li><li>mean: 96.81 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 19 tokens</li><li>mean: 118.21 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task1285kpakeypoint_matching

—Dataset: task1285kpakeypoint_matching
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 30 tokens</li><li>mean: 52.34 tokens</li><li>max: 92 tokens</li></ul> | <ul><li>min: 29 tokens</li><li>mean: 50.22 tokens</li><li>max: 84 tokens</li></ul> | <ul><li>min: 31 tokens</li><li>mean: 53.19 tokens</li><li>max: 88 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task234iircpassagelineanswer_generation

—Dataset: task234iircpassagelineanswer_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 143 tokens</li><li>mean: 235.1 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 155 tokens</li><li>mean: 235.35 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 146 tokens</li><li>mean: 236.27 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task494reviewpolarityanswergeneration

—Dataset: task494reviewpolarityanswergeneration
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 3 tokens</li><li>mean: 106.73 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 23 tokens</li><li>mean: 113.13 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 20 tokens</li><li>mean: 113.28 tokens</li><li>max: 249 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task670ambigqaquestion_generation

—Dataset: task670ambigqaquestion_generation
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 11 tokens</li><li>mean: 12.71 tokens</li><li>max: 26 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 12.5 tokens</li><li>max: 23 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 12.26 tokens</li><li>max: 18 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

task289gigawordsummarization

—Dataset: task289gigawordsummarization
—Size: 1,018 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 25 tokens</li><li>mean: 51.51 tokens</li><li>max: 87 tokens</li></ul> | <ul><li>min: 27 tokens</li><li>mean: 51.94 tokens</li><li>max: 87 tokens</li></ul> | <ul><li>min: 25 tokens</li><li>mean: 51.41 tokens</li><li>max: 87 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

npr

—Dataset: npr
—Size: 24,838 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 4 tokens</li><li>mean: 12.47 tokens</li><li>max: 32 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 149.57 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 119.07 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

nli

—Dataset: nli
—Size: 49,676 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 4 tokens</li><li>mean: 20.86 tokens</li><li>max: 210 tokens</li></ul> | <ul><li>min: 4 tokens</li><li>mean: 11.81 tokens</li><li>max: 44 tokens</li></ul> | <ul><li>min: 4 tokens</li><li>mean: 11.87 tokens</li><li>max: 36 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

SimpleWiki

—Dataset: SimpleWiki
—Size: 5,070 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 8 tokens</li><li>mean: 29.35 tokens</li><li>max: 103 tokens</li></ul> | <ul><li>min: 8 tokens</li><li>mean: 34.56 tokens</li><li>max: 169 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 55.45 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

amazonreview2018

—Dataset: amazonreview2018
—Size: 99,352 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 4 tokens</li><li>mean: 11.46 tokens</li><li>max: 37 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 87.03 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 66.2 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

ccnewstitletext

—Dataset: ccnewstitletext
—Size: 24,838 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 5 tokens</li><li>mean: 15.43 tokens</li><li>max: 51 tokens</li></ul> | <ul><li>min: 19 tokens</li><li>mean: 211.86 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 21 tokens</li><li>mean: 199.81 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

agnews

—Dataset: agnews
—Size: 44,606 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 5 tokens</li><li>mean: 12.02 tokens</li><li>max: 93 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 41.31 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 11 tokens</li><li>mean: 45.88 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

xsum

—Dataset: xsum
—Size: 10,140 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 11 tokens</li><li>mean: 28.09 tokens</li><li>max: 73 tokens</li></ul> | <ul><li>min: 21 tokens</li><li>mean: 227.34 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 29 tokens</li><li>mean: 233.24 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

msmarco

—Dataset: msmarco
—Size: 173,354 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:---------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 4 tokens</li><li>mean: 8.94 tokens</li><li>max: 37 tokens</li></ul> | <ul><li>min: 17 tokens</li><li>mean: 78.62 tokens</li><li>max: 218 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 78.97 tokens</li><li>max: 249 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

yahooanswerstitle_answer

—Dataset: yahooanswerstitle_answer
—Size: 24,838 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 5 tokens</li><li>mean: 17.21 tokens</li><li>max: 109 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 83.07 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 83.24 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

squad_pairs

—Dataset: squad_pairs
—Size: 24,838 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 7 tokens</li><li>mean: 14.39 tokens</li><li>max: 42 tokens</li></ul> | <ul><li>min: 37 tokens</li><li>mean: 151.4 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 28 tokens</li><li>mean: 163.14 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

wow

—Dataset: wow
—Size: 29,908 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 3 tokens</li><li>mean: 86.47 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 65 tokens</li><li>mean: 111.39 tokens</li><li>max: 150 tokens</li></ul> | <ul><li>min: 82 tokens</li><li>mean: 112.66 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

mteb-amazoncounterfactual-avstriplets

—Dataset: mteb-amazoncounterfactual-avstriplets
—Size: 4,055 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 12 tokens</li><li>mean: 27.33 tokens</li><li>max: 120 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 26.92 tokens</li><li>max: 120 tokens</li></ul> | <ul><li>min: 12 tokens</li><li>mean: 26.43 tokens</li><li>max: 90 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

mteb-amazonmassiveintent-avs_triplets

—Dataset: mteb-amazonmassiveintent-avs_triplets
—Size: 11,661 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:---------------------------------------------------------------------------------|:---------------------------------------------------------------------------------|:---------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 3 tokens</li><li>mean: 9.62 tokens</li><li>max: 39 tokens</li></ul> | <ul><li>min: 3 tokens</li><li>mean: 9.01 tokens</li><li>max: 27 tokens</li></ul> | <ul><li>min: 3 tokens</li><li>mean: 9.46 tokens</li><li>max: 32 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

mteb-amazonmassivescenario-avs_triplets

—Dataset: mteb-amazonmassivescenario-avs_triplets
—Size: 11,661 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:---------------------------------------------------------------------------------|:---------------------------------------------------------------------------------|:---------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 3 tokens</li><li>mean: 9.23 tokens</li><li>max: 29 tokens</li></ul> | <ul><li>min: 3 tokens</li><li>mean: 8.93 tokens</li><li>max: 24 tokens</li></ul> | <ul><li>min: 3 tokens</li><li>mean: 9.39 tokens</li><li>max: 24 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

mteb-amazonreviewsmulti-avs_triplets

—Dataset: mteb-amazonreviewsmulti-avs_triplets
—Size: 198,192 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 7 tokens</li><li>mean: 50.21 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 48.47 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 7 tokens</li><li>mean: 50.1 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

mteb-banking77-avs_triplets

—Dataset: mteb-banking77-avs_triplets
—Size: 10,139 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:---------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 4 tokens</li><li>mean: 16.13 tokens</li><li>max: 93 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 16.0 tokens</li><li>max: 87 tokens</li></ul> | <ul><li>min: 4 tokens</li><li>mean: 16.12 tokens</li><li>max: 93 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

mteb-emotion-avs_triplets

—Dataset: mteb-emotion-avs_triplets
—Size: 16,224 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 5 tokens</li><li>mean: 22.65 tokens</li><li>max: 65 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 17.65 tokens</li><li>max: 59 tokens</li></ul> | <ul><li>min: 4 tokens</li><li>mean: 22.29 tokens</li><li>max: 65 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

mteb-imdb-avs_triplets

—Dataset: mteb-imdb-avs_triplets
—Size: 24,839 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 29 tokens</li><li>mean: 204.2 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 45 tokens</li><li>mean: 222.64 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 50 tokens</li><li>mean: 207.1 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

mteb-mtopdomain-avstriplets

—Dataset: mteb-mtopdomain-avstriplets
—Size: 15,715 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:---------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 4 tokens</li><li>mean: 10.18 tokens</li><li>max: 33 tokens</li></ul> | <ul><li>min: 3 tokens</li><li>mean: 9.62 tokens</li><li>max: 26 tokens</li></ul> | <ul><li>min: 4 tokens</li><li>mean: 10.33 tokens</li><li>max: 27 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

mteb-mtopintent-avstriplets

—Dataset: mteb-mtopintent-avstriplets
—Size: 15,715 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:---------------------------------------------------------------------------------|:---------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 3 tokens</li><li>mean: 10.08 tokens</li><li>max: 35 tokens</li></ul> | <ul><li>min: 4 tokens</li><li>mean: 9.68 tokens</li><li>max: 27 tokens</li></ul> | <ul><li>min: 4 tokens</li><li>mean: 9.95 tokens</li><li>max: 33 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

mteb-toxicconversations50k-avs_triplets

—Dataset: mteb-toxicconversations50k-avs_triplets
—Size: 49,677 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 3 tokens</li><li>mean: 67.24 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 3 tokens</li><li>mean: 89.49 tokens</li><li>max: 253 tokens</li></ul> | <ul><li>min: 3 tokens</li><li>mean: 67.95 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

mteb-tweetsentimentextraction-avs_triplets

—Dataset: mteb-tweetsentimentextraction-avs_triplets
—Size: 27,373 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 3 tokens</li><li>mean: 21.29 tokens</li><li>max: 78 tokens</li></ul> | <ul><li>min: 3 tokens</li><li>mean: 20.52 tokens</li><li>max: 54 tokens</li></ul> | <ul><li>min: 3 tokens</li><li>mean: 20.52 tokens</li><li>max: 53 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

covid-bing-query-gpt4-avs_triplets

—Dataset: covid-bing-query-gpt4-avs_triplets
—Size: 5,070 training samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 7 tokens</li><li>mean: 15.27 tokens</li><li>max: 44 tokens</li></ul> | <ul><li>min: 14 tokens</li><li>mean: 37.87 tokens</li><li>max: 239 tokens</li></ul> | <ul><li>min: 16 tokens</li><li>mean: 37.74 tokens</li><li>max: 108 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

Evaluation Dataset

Unnamed Dataset

—Size: 18,269 evaluation samples
—Columns: <code>anchor</code>, <code>positive</code>, and <code>negative</code>
—Approximate statistics based on the first 1000 samples: | | anchor | positive | negative | |:--------|:----------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| | type | string | string | string | | details | <ul><li>min: 5 tokens</li><li>mean: 15.68 tokens</li><li>max: 53 tokens</li></ul> | <ul><li>min: 5 tokens</li><li>mean: 143.02 tokens</li><li>max: 256 tokens</li></ul> | <ul><li>min: 4 tokens</li><li>mean: 145.02 tokens</li><li>max: 256 tokens</li></ul> |
—Loss: <code>GISTEmbedLoss</code> with these parameters:

json

  {'guide': SentenceTransformer(
    (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: NewModel 
    (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
    (2): Dense({'in_features': 1024, 'out_features': 1024, 'bias': True, 'activation_function': 'torch.nn.modules.linear.Identity'})
  ), 'temperature': 0.01}

Training Hyperparameters

Non-Default Hyperparameters

—eval_strategy: steps
—per_device_train_batch_size: 512
—per_device_eval_batch_size: 512
—learning_rate: 2.8284271247461906e-05
—num_train_epochs: 1280
—warmup_ratio: 0.1
—fp16: True
—gradient_checkpointing: True
—batch_sampler: no_duplicates

All Hyperparameters

<details><summary>Click to expand</summary>

—overwrite_output_dir: False
—do_predict: False
—eval_strategy: steps
—prediction_loss_only: True
—per_device_train_batch_size: 512
—per_device_eval_batch_size: 512
—per_gpu_train_batch_size: None
—per_gpu_eval_batch_size: None
—gradient_accumulation_steps: 1
—eval_accumulation_steps: None
—torch_empty_cache_steps: None
—learning_rate: 2.8284271247461906e-05
—weight_decay: 0.0
—adam_beta1: 0.9
—adam_beta2: 0.999
—adam_epsilon: 1e-08
—max_grad_norm: 1.0
—num_train_epochs: 1280
—max_steps: -1
—lr_scheduler_type: linear
—lr_scheduler_kwargs: {}
—warmup_ratio: 0.1
—warmup_steps: 0
—log_level: passive
—log_level_replica: warning
—log_on_each_node: True
—logging_nan_inf_filter: True
—save_safetensors: True
—save_on_each_node: False
—save_only_model: False
—restore_callback_states_from_checkpoint: False
—no_cuda: False
—use_cpu: False
—use_mps_device: False
—seed: 42
—data_seed: None
—jit_mode_eval: False
—use_ipex: False
—bf16: False
—fp16: True
—fp16_opt_level: O1
—half_precision_backend: auto
—bf16_full_eval: False
—fp16_full_eval: False
—tf32: None
—local_rank: 0
—ddp_backend: None
—tpu_num_cores: None
—tpu_metrics_debug: False
—debug: []
—dataloader_drop_last: False
—dataloader_num_workers: 0
—dataloader_prefetch_factor: None
—past_index: -1
—disable_tqdm: False
—remove_unused_columns: True
—label_names: None
—load_best_model_at_end: False
—ignore_data_skip: False
—fsdp: []
—fsdp_min_num_params: 0
—fsdp_config: {'minnumparams': 0, 'xla': False, 'xlafsdpv2': False, 'xlafsdpgrad_ckpt': False}
—fsdp_transformer_layer_cls_to_wrap: None
—accelerator_config: {'splitbatches': False, 'dispatchbatches': None, 'evenbatches': True, 'useseedablesampler': True, 'nonblocking': False, 'gradientaccumulationkwargs': None}
—deepspeed: None
—label_smoothing_factor: 0.0
—optim: adamw_torch
—optim_args: None
—adafactor: False
—group_by_length: False
—length_column_name: length
—ddp_find_unused_parameters: None
—ddp_bucket_cap_mb: None
—ddp_broadcast_buffers: False
—dataloader_pin_memory: True
—dataloader_persistent_workers: False
—skip_memory_metrics: True
—use_legacy_prediction_loop: False
—push_to_hub: False
—resume_from_checkpoint: None
—hub_model_id: None
—hub_strategy: every_save
—hub_private_repo: False
—hub_always_push: False
—gradient_checkpointing: True
—gradient_checkpointing_kwargs: None
—include_inputs_for_metrics: False
—include_for_metrics: []
—eval_do_concat_batches: True
—fp16_backend: auto
—push_to_hub_model_id: None
—push_to_hub_organization: None
—mp_parameters:
—auto_find_batch_size: False
—full_determinism: False
—torchdynamo: None
—ray_scope: last
—ddp_timeout: 1800
—torch_compile: False
—torch_compile_backend: None
—torch_compile_mode: None
—dispatch_batches: None
—split_batches: None
—include_tokens_per_second: False
—include_num_input_tokens_seen: False
—neftune_noise_alpha: None
—optim_target_modules: None
—batch_eval_metrics: False
—eval_on_start: False
—use_liger_kernel: False
—eval_use_gather_object: False
—average_tokens_across_devices: False
—prompts: None
—batch_sampler: no_duplicates
—multi_dataset_batch_sampler: proportional

</details>

Training Logs

Epoch	Step	Training Loss	Validation Loss	medi-mteb-dev_cosine_accuracy
0	0	-	-	0.8422
0.1308	500	11.0208	9.8503	0.8439

Framework Versions

—Python: 3.10.10
—Sentence Transformers: 3.4.0.dev0
—Transformers: 4.46.3
—PyTorch: 2.5.1+cu124
—Accelerate: 0.34.2
—Datasets: 2.21.0
—Tokenizers: 0.20.4

Citation

BibTeX

Sentence Transformers

bibtex

@inproceedings{reimers-2019-sentence-bert,
    title = "Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks",
    author = "Reimers, Nils and Gurevych, Iryna",
    booktitle = "Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing",
    month = "11",
    year = "2019",
    publisher = "Association for Computational Linguistics",
    url = "https://arxiv.org/abs/1908.10084",
}

GISTEmbedLoss

bibtex

@misc{solatorio2024gistembed,
    title={GISTEmbed: Guided In-sample Selection of Training Negatives for Text Embedding Fine-tuning},
    author={Aivin V. Solatorio},
    year={2024},
    eprint={2402.16829},
    archivePrefix={arXiv},
    primaryClass={cs.LG}
}

<!--

Glossary

Clearly define terms in order to be accessible across audiences. -->

<!--

Model Card Authors

Lists the people who create the model card, providing recognition and accountability for the detailed work that goes into its construction. -->

<!--

Model Card Contact

Provides a way for people who have updates to the Model Card, suggestions, or questions, to contact the Model Card authors. -->