Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+tokenizer.json filter=lfs diff=lfs merge=lfs -text

1_Pooling/config.json

@@ -0,0 +1,10 @@
+{
+    "word_embedding_dimension": 768,
+    "pooling_mode_cls_token": true,
+    "pooling_mode_mean_tokens": false,
+    "pooling_mode_max_tokens": false,
+    "pooling_mode_mean_sqrt_len_tokens": false,
+    "pooling_mode_weightedmean_tokens": false,
+    "pooling_mode_lasttoken": false,
+    "include_prompt": true
+}

README.md

@@ -0,0 +1,834 @@
+---
+tags:
+- sentence-transformers
+- sentence-similarity
+- feature-extraction
+- dense
+- generated_from_trainer
+- dataset_size:200000
+- loss:MultipleNegativesRankingLoss
+base_model: Alibaba-NLP/gte-multilingual-base
+widget:
+- source_sentence: "TRIBUNAL DE JUSTIÇA DO ESTADO DO RIO DE JANEIRO\neJUD TJRJ\n15/01/2024\
+    \ 14:44\nEmitido em:\nSECRETARIA DA 7ª CÂMARA DE DIREITO PÚBLICO\nProcesso: 0100621-07.2017.8.19.0001\
+    \ - APELAÇÃO\nINTIMAÇÃO ELETRÔNICA\nRio de Janeiro, 15 de janeiro de  2024\nFica\
+    \ V. Sª / V. Exª intimado da determinação abaixo:\nApelante: Centro de Estudos\
+    \ Jurídicos da Defensoria Pública Geral do Estado do Rio de Janeiro \nApelado\
+    \ 1: Estado do Rio de Janeiro \nApelado 2: Município do Rio de Janeiro\nRelator:\
+    \ Des. Maria Christina Berardo Rücker\nDECISÃO MONOCRÁTICA\nAPELAÇÃO CÍVEL. DIREITO\
+    \ CONSTITUCIONAL. MEDICAMENTOS. MORTE DO AUTOR. EXTINÇÃO\nSEM APRECIAÇÃO DO MÉRITO.\
+    \ SUCUMBÊNCIA. FALHA DO PODER PÚBLICO NA GARANTIA DO\nDIREITO FUNDAMENTAL À SAÚDE.\
+    \ PRINCÍPIO DA CAUSALIDADE. PEQUENO REPARO NO\nPRONUNCIAMENTO, PARA CONDENAR AMBOS\
+    \ OS RÉUS AO PAGAMENTO DE HONORÁRIOS\nSUCUMBENCIAIS. \n1. Sentença que julgou\
+    \ extinta a ação em que se buscava tratamento médico e exames, diante da morte\
+    \ do autor e\nda ausência de habilitação de herdeiros, condenado o demandante\
+    \ ao pagamento do ônus sucumbencial, observada\na gratuidade de justiça. \n2.\
+    \ O Superior Tribunal de Justiça entende que, nas hipóteses de extinção do processo\
+    \ sem resolução do mérito,\ndecorrente de perda de objeto superveniente ao ajuizamento\
+    \ da ação, a parte que deu causa à instauração do\nprocesso deverá suportar o\
+    \ pagamento dos honorários advocatícios. \n3. Evidente falha do Poder Público\
+    \ no cumprimento de seu dever solidário na garantia do direito fundamental à\n\
+    saúde, expresso no Enunciado nº 65 deste Tribunal de Justiça, o que ensejou a\
+    \ propositura da presente demanda."
+  sentences:
+  - "Poder Judiciário do Estado do Rio de Janeiro \nDécima Primeira Câmara Cível \n\
+    \ \n \n \n \n \n \n \nSecretaria da Décima Primeira Câmara Cível \nRua Dom Manuel\
+    \ nº 37  \nCentro – Rio de Janeiro/RJ  \nJr \n \n \nRELATÓRIO \n \n \nTrata-se\
+    \ de Embargos de Declarações opostos por\n Geysa Conceição \nNascimento Laurino\
+    \ e Outros\n , às fls.290/292, e, pelo \nMunicípio do Rio de Janeiro\n  \ncontra\
+    \ o v. acórdão de fls. 257/266. \n \nAduzem as primeiras Embargantes que houve\
+    \ omissão no julgado, uma vez \nque não foi apreciado o requerimento de deferimento\
+    \ da gratuidade de Justiça \nformulada no apelo. \n \nRequerem, por final, seja\
+    \ conhecido e provido o recurso para que seja \nsanada a omissão apontada, dando-se\
+    \ efeitos infringentes ao julgado, a fim de que \nseja deferido o requerimento\
+    \ da gratuidade de justiça formulado. \n \nAlega o segundo Embargante que houve\
+    \ omissão e contradição no v. \nacórdão, tendo o julgado contrariado o art. 169,\
+    \ § 1º, I e II da Carta Magna. Que, \ninexiste previsão legal que ampare o pleito\
+    \ autoral. Que o v. acórdão violou texto \nconstitucional, e, por analogia a Súmula\
+    \ 37 do Pretório Excelso.  \n \nRequer, por final, seja conhecido e provido os\
+    \ embargos declaratórios, para \nque  sejam  sanadas  as  contradições  e  omissões\
+    \  apontadas,  com  os  efeitos  daí  \ndecorrentes,  notadamente  a  contrariedade\
+    \  ao  art. 169, § 1º, I e II do texto \nconstitucional, além dos arts.1º; 2º;\
+    \ 5º, II; 18 e 37 do Texto Constitucional e por"
+  - "26/05/1994. \nIII. O Tribunal de origem, com base no exame dos \nelementos fáticos\
+    \ dos autos e das cláusulas do \ncontrato \nfirmado \nentre \nas \npartes, \n\
+    concluiu que, \"considerando também a inexistência \nde aditivo contratual posterior\
+    \ que estabeleça a \npossibilidade de atualização monetária -, é de se \nconcluir\
+    \ que a avença deve ser cumprida nos \ntermos pactuados e anuídos pelas partes\
+    \ (neles \nincluídos os valores constantes nas tabelas da \nOrdem \nde \nServiço\
+    \ \nINSS/PG \nn° \n17/1994, \nestipulados de acordo com o novo ambiente de \n\
+    estabilização \neconômica)\". \nIV. Assim, nos termos em que a causa fora decidida,\
+    \ \ninfirmaras conclusões do julgado ? de que inexistiria \nprevisão \ncontratual\
+    \ \nde \nreajuste dos serviços advocatícios ? demandaria, \nnecessariamente, \n\
+    a análise das cláusulas do \nreferido contrato, bem como a incursão no \nconteúdo\
+    \ fático-probatório dos autos, o que é \nvedado, em sede de Recurso Especial,\
+    \ em razão \ndos óbices das Súmulas 5 e 7 do STJ\n, \n328"
+  - "TRIBUNAL DE JUSTIÇA DO ESTADO DO RIO DE JANEIRO\neJUD TJRJ\n15/01/2024 14:44\n\
+    Emitido em:\n            \n(...) Assim, tendo em vista o falecimento do Autor\
+    \ (certidão de óbito de fl.273), bem como a certidão de inércia de\nmanifestação\
+    \ de possíveis sucessores a se habilitarem no feito às f. 295 e da diligência\
+    \ negativa às f, 281/282, já\ntendo transcorrido anos do óbito sem qualquer habilitação\
+    \ de herdeiros, forçoso reconhecer a falta de pressuposto\nprocessual (existência\
+    \ de parte), de forma que JULGO EXTINTO O PROCESSO, SEM APRECIAÇÃO DO\nMÉRITO,\
+    \ na forma do Art. 485, IV, do CPC. \n \nCustas e honorários de 10% sobre o valor\
+    \ da causa pela autora, com exigibilidade suspensa face a gratuidade de\njustiça\
+    \ deferida. Certificado o trânsito em julgado, diligencie-se como de praxe para\
+    \ fins de baixa e arquivamento.\nP.I.  \n           Em suas razões, a DEFENSORIA\
+    \ PÚBLICA reitera que os réus deram causa à demanda, de forma que\ndevem ser condenados\
+    \ ao pagamento dos honorários sucumbenciais (índex 326).\n           \n      \
+    \     Contrarrazões pelo Estado (índex 341).\n            \n           Sem contrarrazões\
+    \ pelo Município (índex 349). \n            \n           Parecer da d. Procuradoria\
+    \ de Justiça pelo provimento do recurso (índex 360).\n           \n          \
+    \ Decisão proferida pela i. relatora originária, em que declinada a competência\
+    \ em favor de uma das Câmaras\nde Direito Público deste Tribunal de Justiça (índex\
+    \ 365).\n           \n           \n           É o relatório. Decido. \n      \
+    \     \n           Presentes os requisitos intrínsecos e extrínsecos de admissibilidade,\
+    \ conheço da apelação. \n           \n           As partes controvertem neste\
+    \ recurso tão somente quanto aos honorários sucumbenciais devidos em virtude\n\
+    da extinção do feito, em que se buscava tratamento médico e exames, diante da\
+    \ morte do autor e da ausência de"
+- source_sentence: "Poder Judiciário do Estado do Rio de Janeiro \nGabinete da Terceira\
+    \ Vice-Presidência \n \n_______________________________________________________________________________\
+    \ \n \n__________________________________________________________________________________________________\
+    \ \n \nAv. Erasmo Braga, 115 –11º andar – Lâmina II - Centro – Rio de Janeiro/RJ\
+    \ \n          \nCEP 20020-903 - Tel.: + 55 21 3133-4103 - e-mail: [email protected]\
+    \ \n \nRecurso Especial Cível nº 0106806-90.2019.8.19.0001 \nRecorrente: \nMUNICÍPIO\
+    \ DO RIO DE JANEIRO \nRecorrido: \nESPÓLIO \nDE \nFLÁVIO \nAUGUSTO \nSALLES \n\
+    NOBRE \nREP/P/S/INVENTARIANTE EDUARDO FARIAS VASQUEZ \n \n \nDECISÃO \n \n \n\
+    Trata-se de recurso especial tempestivo, fls. 300/310, com fundamento \nno artigo\
+    \ 105, inciso III, alínea “a”, da Constituição Federal, interposto em face dos\
+    \ \nacórdãos da Quinta Câmara de Direito Privado (antiga Vigésima Quarta Câmara\
+    \ \nCível), fls. 244/253 e 287/296, assim ementados:  \n \n“APELAÇÃO \n \nCÍVEL.\
+    \ \n \nDIREITO  \nADMINISTRATIVO.  AÇÃO  DE ANULAÇÃO  DE  \nDÉBITO  FISCAL.  RETIFICAÇÃO\
+    \  DA TIPOLOGIA  \nDO  IMÓVEL  NO  CADASTRO  DE  IPTU. \nREVISÃO  DO  LANÇAMENTO\
+    \  DE  IPTU  DOS  \nEXERCÍCIOS \nDE \n2013 \nA \n2018, \nGERANDO \nCOBRANÇA COMPLEMENTAR.\
+    \ SENTENÇA  DE  \nPROCEDENCIA.  IRRESIGNAÇÃO  DO MUNICIPIO  \nREU.  RETROATIVIDADE\
+    \  DA  EXAÇÃO  AO \nARGUMENTO  DE  QUE  HOUVE  ERRO  DE  \nFATO."
+  sentences:
+  - "5 \nobrigações do beneficiário. Impossibilidade de reserva de \nhonorários em\
+    \ razão das Agravadas serem beneficiárias \nde gratuidade de justiça. RECURSO\
+    \ DESPROVIDO.  \n(0051040-89.2018.8.19.0000 \n- \nAGRAVO \nDE \nINSTRUMENTO -\
+    \ Des(a). DENISE NICOLL SIMÕES - \nJulgamento: 30/10/2018 - QUINTA CÂMARA CÍVEL)\
+    \ \n   \nAGRAVO DE INSTRUMENTO. REVOGAÇÃO DO \nBENEFÍCIO DE GRATUIDADE DE JUSTIÇA\
+    \ NO \nCURSO \nDA \nFASE \nDE \nCUMPRIMENTO \nDE \nSENTENÇA. 1.O fato de a agravante\
+    \ ter se tornado \ncredora de quantia objeto de execução, por si só, não é \n\
+    suficiente para se concluir como desatendidos os \npressupostos para a fruição\
+    \ do benefício em questão. 2.A \nrevogação do benefício da gratuidade de justiça\
+    \ com base \nno recebimento da indenização resultaria em desatenção \nao princípio\
+    \ da restitutio in integrum. RECURSO \nPROVIDO, NA FORMA DO ART. 557, §1º-A, CPC.\
+    \   \n(0069223-16.2015.8.19.0000 \n- \nAGRAVO \nDE \nINSTRUMENTO - Des(a). FERNANDO\
+    \ CERQUEIRA \nCHAGAS - Julgamento: 10/03/2016 - DÉCIMA PRIMEIRA \nCÂMARA CÍVEL)\
+    \ \n   \nAPELAÇÃO CÍVEL. IMPUGNAÇÃO À GRATUIDADE \nDE \nJUSTIÇA. \nVALORES \n\
+    RECEBIDOS \nPELA \nAPELADA \nDECORRENTES \nDE \nAÇÃO \nINDENIZATÓRIA \nPROPOSTA\
+    \ \nEM \nFACE \nDA \nAPELANTE \nQUE \nNÃO \nDESCARACTERIZA \nA \nHIPOSSUFICIÊNCIA\
+    \ ECONÔMICA. RECURSO A \nQUE SE NEGA PROVIMENTO, NA FORMA DO ART. \n1436"
+  - "Poder Judiciário do Estado do Rio de Janeiro\n \nGabinete da Terceira Vice-Presidência\n\
+    \ \n \n \nAv. Erasmo Braga, 115 –11º andar – Lâmina II\n \nCentro – Rio de Janeiro/RJ\
+    \ – CEP 20020-903\n \nTel.: + 55 21 3133-4103 e-mail: [email protected]\n\
+    \ \ntendo sequer apresentado contrarrazões ao presente \nrecurso. (...)”\n \n\
+    \ \n \nVerifica-se que o colegiado concluiu pela responsabilidade da recorrente\
+    \ \npelo exame dos fatos e provas dos autos bem como pela relação negocial entre\
+    \ as \npartes o que esbarra no óbice da \nSúmula n° 7 do STJ\n (“A pretensão de\
+    \ simples \nreexame de prova não enseja recurso especial”; Corte Especial; julgado\
+    \ em \n28/06/1990; DJ 03/07/1990) bem como da \nSúmula n° 5\n \ndo STJ\n (“A SIMPLES\
+    \ \nINTERPRETAÇÃO DE CLAUSULA CONTRATUAL NÃO ENSEJA RECURSO \nESPECIAL”; Corte\
+    \ Especial; julgado em 10/05/1990; DJ 21/05/1990, p. 4407). Neste \nsentido:\n\
+    \ \n \n \n \n \n“\nPROCESSUAL \nCIVIL. \nAGRAVO \nINTERNO \nNO \nAGRAVO EM RECURSO\
+    \ ESPECIAL. REEXAME DE \nFATOS E PROVAS. SÚMULA 7 DO SUPERIOR \nTRIBUNAL DE JUSTIÇA.\n\
+    \ \n1. \nNão cabe, em recurso especial, reexaminar \nmatéria de fato (Súmula 7/STJ).\n\
+    \ \n2. Agravo interno a que se nega provimento.\n \n(AgInt no AgRg no AREsp 830.868/RS,\
+    \ Rel. Ministra \nMARIA ISABEL GALLOTTI, QUARTA TURMA, julgado \nem 18/10/2016,\
+    \ DJe 21/10/2016)”"
+  - "Poder Judiciário do Estado do Rio de Janeiro \nGabinete da Terceira Vice-Presidência\
+    \ \n \n_______________________________________________________________________________\
+    \ \n \n__________________________________________________________________________________________________\
+    \ \n \nAv. Erasmo Braga, 115 –11º andar – Lâmina II - Centro – Rio de Janeiro/RJ\
+    \ \n          \nCEP 20020-903 - Tel.: + 55 21 3133-4103 - e-mail: [email protected]\
+    \ \n \nMATÉRIAS \nSUSCITADAS \nQUE \nFORAM \nOSTENSIVAMENTE \nDEBATIDAS \nNO \
+    \ \nJULGAMENTO  DA  APELAÇÃO  –  VEICULAÇÃO  \nDE MERA IRRESIGNAÇÃO – BUSCA DE\
+    \ NOVO \nJULGAMENTO COM  REAPRECIAÇÃO  DO  \nMÉRITO  –  IMPOSSIBILIDADE POR  VIA\
+    \  DE  \nEMBARGOS  DE  DECLARAÇÃO  –  PRÉ-\nQUESTIONAMENTO  FICTO  (ART.  1.025,\
+    \  CPC)  -  \nRECURSO REJEITADO. 1. Os embargos de declaração \nsão recurso de\
+    \ fundamentação vinculada,  sendo  cabíveis  \ntão  somente  para  esclarecer\
+    \ obscuridade, eliminar \ncontradição, suprir omissão ou corrigir erro material\
+    \ na \ndecisão embargada (art. 1.022, inc. I a III, do CPC). 2.  In  \ncasu, \
+    \ inexistem  os  vícios  alegados  pela  embargante  na \npetição  de  interposição\
+    \  dos  aclaratórios,  revelando-se  o  \nclaro intento  de  reexame  da  controvérsia\
+    \  diante  de  \nsimples irresignação quanto à solução jurídica oferecida, à \n\
+    unanimidade, pelo órgão colegiado.  3. Desamparados por \nomissão, contradição,\
+    \ obscuridade ou erro material na \ndecisão recorrida, os embargos de declaração\
+    \ não são via \nprópria ao novo julgamento da causa. Precedentes do"
+- source_sentence: "SEABRA, BALTZ & PEREIRA – ADVOGADOS ASSOCIADOS \nRua Senador Dantas\
+    \ n. 117 – sala 2140, Centro, Rio de Janeiro – RJ. \nCel. e WhatsApp: (21) 9.9583-0991\
+    \ \n \nEXMO. SR. DR. DESEMBARGADOR 3º VICE-PRESIDENTE DO EGRÉGIO \nTRIBUNAL DE\
+    \ JUSTIÇA DO ESTADO DO RIO DE JANEIRO \n \n \nProcesso nº\n 0124238-45.2007.8.19.0001\
+    \ \nPrioridade: \nPessoa Idosa\n \nELIZABETH GUIMARÃES COSTA\n, \nbeneficiária\
+    \ da gratuidade de \njustiça\n, conforme fls. 62 (índex 64), já qualificada, nos\
+    \ autos do processo em epígrafe, \nAÇÃO DE CONSIGNAÇÃO EM PAGAMENTO, movida em\
+    \ face do \nINSTITUTO DE \nPREVIDÊNCIA DO MUNICÍPIO DO RIO DE JANEIRO – PREVRIO\n\
+    , igualmente \nqualificado, \nvem \npor \nseu \nadvogado \ninfra-assinado, \n\
+    tempestivamente, \napresentar: \nCONTRARRAZÕES AO RECURSO ESPECIAL \n \noposto\
+    \ contra o R. Acórdão de fls. 698/702, conforme fls. 704/716, nos \ntermos das\
+    \ razões em anexo. \nIsto \nposto, \nrequerer \nque \nsejam \nencaminhadas \n\
+    estas \ncontrarrazões ao Egrégio Superior Tribunal de Justiça, fazendo-as, segundo\
+    \ \na fundamentação anexada e requerendo, desde já, que seja o presente \npetitório\
+    \ recebido regularmente, processado e remetido àquela Corte \nSuperior do Poder\
+    \ Judiciário. \nTermos em que \nPede Deferimento. \nRio de Janeiro, 20 de março\
+    \ de 2024. \n \nPEDRO LUIZ B. S. F. S. PEREIRA \nOAB-RJ n.º 119.021 \nTJRJ 202400222539\
+    \ 20/03/2024 22:30:00 KRCI - PETIÇÃO ELETRÔNICA Assinada por PEDRO LUIZ BALTAZAR\
+    \ SA FREIRE SEABRA PEREIRA\n728"
+  sentences:
+  - "SEABRA, BALTZ & PEREIRA – ADVOGADOS ASSOCIADOS \nRua Senador Dantas n. 117 –\
+    \ sala 2140, Centro, Rio de Janeiro – RJ. \nCel. e WhatsApp: (21) 9.9583-0991\
+    \ \n \nAdemais, na aplicação da lei, o juiz atenderá aos fins sociais a \nque\
+    \ ela se dirige e também às exigências do bem comum, conforme dispõe o \nart.\
+    \ 5º da Lei de Introdução às Normas do Direito Brasileiro.  \nDestarte, na aplicação\
+    \ da aludida norma, há que se a ter ao \nseu fim social almejado, qual seja, dar\
+    \ moradia digna, conforme deseja o \nintuito do legislador da CF/88.  \nAssim,\
+    \ não só se atende ao disposto no art. 5º XXIII da CRFB, \ncomo o princípio da\
+    \ dignidade da pessoa, disposto no art. 1º, III da mesma \nCarta Magna. \nA recorrente\
+    \ não se ateve a finalidade da referida norma, pois, \nao não a observar, propiciou\
+    \ o desequilíbrio contratual, já que a dívida não \nfoi reduzida ao logo do seu\
+    \ pagamento.  \nExtrai-se disso, que há uma onerosidade excessiva, que lesa \n\
+    não somente o patrimônio da recorrente, mas sua dignidade, frustrando o \ndesiderato\
+    \ constitucional, como já narrado. \nDessa onerosidade excessiva há um plus, o\
+    \ qual se traduz em \nenriquecimento sem causa, já que por mais que se pagasse\
+    \ as prestações, a \ndívida não se reduz. \nO ônus excessivo está em desacordo\
+    \ não só com o equilíbrio \ncontratual, como lesa a boa-fé objetiva que deveria\
+    \ margear o contrato.  \nA parte hipossificiente, que é a recorrida, a qual não\
+    \ possui \nqualquer gerência para renegociação das cláusulas contratuais, quando\
+    \ \nestas deveriam, ser interpretadas de maneira mais favorável ao consumidor\
+    \ \nsegundo a luz do art. 47 do CDC.  \nUm dos direitos básicos é a modificação\
+    \ das cláusulas \ncontratuais que estabeleçam prestações desproporcionais ou sua\
+    \ revisão em \nrazão de fatos supervenientes que as tornem excessivamente onerosas\
+    \ (art. \n6º, V, CDC).  \n744"
+  - "TRIBUNAL DE JUSTIÇA DO RIO DE JANEIRO\neJUD TJRJ\n19/03/2021 13:05\nEmitido em:\n\
+    RECURSO ESPECIAL. EMBARGOS DE DECLARAÇÃO. ALEGADA VIOLAÇÃO DO ART. 535 DO CPC.\n\
+    INEXISTÊNCIA. AUSÊNCIA DAS HIPÓTESES DE CABIMENTO. CERTIDÃO DE DÍVIDA ATIVA.\n\
+    PRESUNÇÃO DE CERTEZA E LIQUIDEZ NÃO ELIDIDA NA INSTRUÇÃO PROBATÓRIA. DECISÃO\n\
+    FUNDAMENTADA NA PROVA DOS AUTOS. 1. A omissão que enseja o cabimento dos embargos\
+    \ de\ndeclaração é aquela existente em relação aos questionamentos aos quais o\
+    \ julgador deveria se pronunciar, e não em\nrelação àqueles que a parte quer ver\
+    \ julgados. 2. A contradição permissiva da oposição de embargos de declaração\n\
+    é a que se faz presente dentro da própria decisão, e não quanto aos argumentos\
+    \ ou provas apresentadas pelas partes.\n3. A obscuridade passível de correção\
+    \ é a que se detecta no texto da decisão, referente à falta de clareza, sem\n\
+    relação com a análise das provas dos autos. 4. Ausência de violação do art. 535\
+    \ do Código de Processo Civil.\nDecisões proferidas com base nas provas dos autos.\
+    \ 5. Recurso especial não provido. (REsp 928.075/PE, Rel.\nMinistro CASTRO MEIRA,\
+    \ SEGUNDA TURMA, julgado em 04/09/2007, DJ 18/09/2007, p. 290)\n         No que\
+    \ tange à instauração do incidente de inconstitucionalidade, requerida pelo apelante,\
+    \ com referência ao\nartigo 6º, inciso I, da Lei Municipal nº 3.720/2004, trata-se\
+    \ de questão analisada no acórdão embargado, que se\napresentou adequadamente\
+    \ fundamentado ao rejeitá-la. \n         Ademais, a rigor, apenas se imporia a\
+    \ instauração do referido incidente na hipótese em que o Órgão\nFracionário entendesse\
+    \ pela existência do vício suscitado pela parte, o que, neste caso, não ocorre,\
+    \ visto que o"
+  - "TRIBUNAL DE JUSTIÇA DO RIO DE JANEIRO\neJUD TJRJ\n28/04/2022 10:19\nEmitido em:\n\
+    extraordinário, quando não ventilada, na decisão recorrida, a questão federal\
+    \ suscitada\") e 356 (\"O ponto omisso da\ndecisão, sobre o qual não foram opostos\
+    \ embargos declaratórios, não pode ser objeto de recurso extraordinário, por\n\
+    faltar o requisito do prequestionamento\") da súmula da jurisprudência do STF.\
+    \ \n            \n            Ainda que assim não fosse, verifica-se que o v.\
+    \ Acórdão recorrido decidiu a lide valendo-se de\ninterpretação de legislação\
+    \ local: Decretos nº 32.115/2010 e         nº 38.197/13, que dispõem sobre a demolição,\n\
+    realocação e o pagamento de tal benefício nos casos de desocupação de áreas de\
+    \ assentamentos populares,\nnecessárias à implantação de projetos de interesse\
+    \ público, ou em situações de risco e emergência.\n            \n            Tal\
+    \ circunstância distancia o caso concreto das competências definidas pela Constituição\
+    \ da República para\nas Cortes Superiores, configurando hipótese que atrai a incidência\
+    \ dos verbetes sumulares nº 279 e 280 do STF. \n            \n            Nesse\
+    \ sentido:\n             \n\"RECURSO EXTRAORDINÁRIO - MATÉRIA FÁTICA - DIREITO\
+    \ LOCAL. O recurso extraordinário não se\npresta à reapreciação da controvérsia\
+    \ no que dirimida à luz dos elementos probatórios dos autos e considerado o\n\
+    direito local - verbetes de nºs 279 e 280 da Súmula do Supremo Tribunal Federal.\
+    \ Hipótese em que se concluiu\npelo direito à gratificação especial decorrente\
+    \ do desempenho em local insalubre e perigoso. (RE 119216 AgR,\nRelator(a): MARCO\
+    \ AURÉLIO, Segunda Turma, julgado em 04/03/1997, DJ 23-05-1997 PP-21735 EMENT\n\
+    VOL-01870-01 PP-00127)\"\n            \n            À vista do exposto, DEIXO\
+    \ DE ADMITIR o recurso extraordinário interposto.\n            Publique-se.\n\
+    Rio de Janeiro, 26 de abril de 2022.\nDesembargador EDSON VASCONCELOS"
+- source_sentence: "T\nodo conteúdo disponível nesta página é meramente informativo,\
+    \ não substitui em hipótese alguma, a publicação Oficial\n \n  \nSUSPENSÃO DE\
+    \ PRAZOS E DE EXPEDIENTE FORENSE \n \nCALENDÁRIO DE FERIADOS \nData da atualização:\
+    \ 14.04.2023\n \n2023\n \n \n \nConsulta aos atos oficiais do PJERJ e à legislação\
+    \ que instituem feriados, pontos \nfacultativos e suspensão de atividades. \n\
+    \ \n \n \n \n \n \n\n \nConsulta por Assunto \n \n \n\n \nConsulta por Comarca\
+    \ \n \n \n \n\n \nConsulta de feriados, pontos facultativos e outras ocorrências\
+    \ com \nabrangência de todo o Estado ou toda Capital\n.   \n \n \n \n \n \n \n\
+    \ \n \n \n \n \n \n \n \n \n \n \n \n \n \nTJRJ 202300285811 27/04/2023 18:12:00\
+    \ H=JI - PETIÇÃO ELETRÔNICA Assinada por RODRIGO SALGADO MARTINS\n889"
+  sentences:
+  - "PRAZO  DE  90  (NOVENTA)  DIAS,  BEM  COMO  ARRESTANDO  A\nVERBA  NECESSÁRIA\
+    \  AO  CUSTEIO  DAS  OBRAS  E  SERVIÇOS.\nINÉRCIA  DO  MUNICÍPIO.  SENTENÇA  DE\
+    \  PROVIMENTO,\nCONFIRMANDO  A  TUTELA  DEFERIDA,  E  CONDENANDO  O\nMUNICÍPIO\
+    \ A REALIZAR AS OBRAS E SERVIÇOS MENCIONADOS.\nAPELO  DO  MUNICÍPIO/RÉU.  ALEGAÇÃO\
+    \  DE  AUSÊNCIA  DE\nRECURSOS,  BEM  COMO  DE  VIOLAÇÃO  AO  PRINCÍPIO  DA\nSEPARAÇÃO\n\
+    \ \nDE\n \nPODERES,\n \nARGUINDO,\n \nAINDA,\n \nA\nIMPOSSIBILIDADE  DE  PROMOÇÃO\
+    \  DE  ARRESTO  DAS  VERBAS\nPÚBLICAS.  CONSELHO  TUTELAR  QUE  CONSITUI  ÓRGÃO\n\
+    PERMANENTE  E  AUTÔNOMO,  A QUEM  INCUMBE  ZELAR  PELO\n4\n833"
+  - "Classif. documental\n00.00.04.22\nPREFEITURA DA CIDADE DO RIO DE JANEIRO\nSECRETARIA\
+    \ MUNICIPAL DE FAZENDA E PLANEJAMENTO / SMFP\nDESPACHO Nº SMF-DES-2024/52208\n\
+    Assunto: INFORMAÇÃO PARA SUBSIDIAR AÇÕES JUDICIAIS\nA(o) FP/REC-RIO/CIP-1,\nPara\
+    \ análise.\nRio de Janeiro, 09 de abril de 2024.\nVINICIUS ALVES FERREIRA \nAGENTE\
+    \ DE FAZENDA \nMatrícula: 2951804 \nFP/REC-RIO/CIP\nSMFDES202452208A\nAssinado\
+    \ com senha por VINICIUS ALVES FERREIRA - 09/04/2024 às 19:11:20.\nDocumento Nº:\
+    \ 5659977-8892 - consulta à autenticidade em\nhttps://acesso.processo.rio/sigaex/public/app/autenticar?n=5659977-8892\n\
+    386"
+  - "Santo Antônio de Pádua \nPeríodo \n \nAto  \n \nPublicação \nEmenta \n09/01/2023,\
+    \ \n11/01/2023 e \n12/01/2023 \nATO EXECUTIVO Nº \n2, DE 12/01/2023\n \nDJERJ,\
+    \ ADM, n. 85, p. 3.  \n13/01/2023\n \nResolve suspender as atividades \npresenciais\
+    \ \ne \nos \nprazos \nprocessuais na Comarca de Santo \nAntônio \nde \nPádua,\
+    \ \nnos \ndias \n09/01/2023, \n11/01/2023 \ne \n12/01/2023.\n \nÍndice \nSão Gonçalo\
+    \ \nPeríodo \n \nAto  \n \nPublicação \nEmenta \n14/02/2023 \nATO EXECUTIVO Nº\
+    \ \n41, DE 14/02/2023\n \nDJERJ, ADM, n. 110, p. 3. \n24/02/2023 \nResolve suspender\
+    \ \nos \nprazos \nprocessuais na Comarca de São \nGonçalo, no dia 14 de fevereiro\
+    \ de \n2023. \n07/02/2023 e \n08/02/2023 \nATO EXECUTIVO Nº \n36, DE 10/02/2023\n\
+    \ \nDJERJ, ADM, n. 106, p. 9. \n14/02/2023\n \nResolve suspender \nos \nprazos\
+    \ \nprocessuais na Comarca da Capital \ne nas Comarcas de Belford Roxo, \nDuque\
+    \ de Caxias, Guapimirim, \nItaboraí, Itaguaí, Japeri, Magé, \nNilópolis, Niterói,\
+    \ Nova Iguaçu/ \nMesquita, Paracambi, Queimados, \nSão Gonçalo, São João de Meriti,\
+    \ \nSeropédica e Maricá, nos dias 07 e \n08 de fevereiro de 2023.\n \n898"
+- source_sentence: "PROCURADORIA GERAL DO ESTADO DO RIO DE JANEIRO \nPROCURADORIA\
+    \ DE SERVIÇOS DE SAÚDE (PG-16) \n \nEXMO. SR. DR. DES. 3º PRESIDENTE DO TRIBUNAL\
+    \ DE JUSTIÇA DO RIO DE \nJANEIRO \n \n \n \nProcesso 0076107-19.2019.8.19.0001\
+    \ \n \n \n \nO\n ESTADO DO RIO DE JANEIRO, \npela Procuradoria Geral do Estado,\
+    \ \nnos autos do recurso extraordinário interposto por \nPERCEDINA DOS SANTOS\
+    \ TORRES e \noutro\n,\n \nvem, tempestivamente, apresentar suas \n \n \nCONTRARRAZÕES\
+    \ DE RECURSO EXTRAORDINÁRIO \n \n \npelos fundamentos jurídicos expostos na peça\
+    \ em anexo, esperando, desde já, pelo não \nconhecimento ou pelo desprovimento\
+    \ do recurso, como de Direito. \n \nPede deferimento. \nRio de Janeiro, 26 de\
+    \ janeiro de 2021.  \n \n \n \nLETICIA LACROIX DE OLIVEIRA \nP\nROCURADORA DO\
+    \ \nE\nSTADO\n \n \n \n \n \n \n \nTJRJ 202100041683 27/01/2021 00:06:00 GPLI\
+    \ - PETIÇÃO ELETRÔNICA Assinada por LETICIA LACROIX DE OLIVEIRA\n373\nDigitally\
+    \ signed by LETICIA LACROIX DE OLIVEIRA:04296848780\nDate: 2021.01.26 21:23:08\
+    \ BRST"
+  sentences:
+  - "PROCURADORIA GERAL DO ESTADO DO RIO DE JANEIRO \nPROCURADORIA DE SERVIÇOS DE\
+    \ SAÚDE (PG-16) \n \n \n3 \n \n          Na prática, pode-se concluir que o acórdão\
+    \ recorrido revogou toda a \njurisprudência sumular dos Tribunais Superiores,\
+    \ entendendo ser aplicável um julgado do STF \nque, numa ação rescisória e em\
+    \ caráter incidental, acredita ser cabível o pagamento de \nhonorários advocatícios\
+    \ à Defensoria Pública pelo mesmo ente federado responsável por seu \nfuncionamento.\
+    \ Situação que, \npermissa venia\n, é inadmissível e viola frontalmente o \nordenamento\
+    \ jurídico vigente. \n \n         Uma outra questão jurídica diz respeito à possibilidade\
+    \ de este acórdão do STF, \nque como já se disse, decidiu sobre o tema em caráter\
+    \ incidental e não tem caráter vinculante, \nrevogar a própria Súmula 421 do STJ.\
+    \ Um acórdão que decide um tema de modo incidental \nrevoga automaticamente as\
+    \ Súmulas dos outros Tribunais? \nData venia\n, parece-nos que não.  \n \nII -\
+    \ ILEGALIDADE DO PAGAMENTO DE HONORÁRIOS PELO ESTADO EM \nFAVOR DA DEFENSORIA\
+    \ PÚBLICA – OCORRÊNCIA DA CONFUSÃO (ARTIGO \n381 DO CÓDIGO CIVIL) – TEMA PACIFICADO\
+    \ PELO E. STJ\n \n  \nRememore-se, por oportuno, que já está pacificado na doutrina\
+    \ e na jurisprudência \no entendimento de que há confusão na condenação do Estado\
+    \ ao pagamento de honorários \nsucumbenciais à Defensoria Pública, nos termos\
+    \ do que estabelece o artigo 381 do Código Civil, \nverbis\n: \n \nArt. 381 –\
+    \ Extingue-se a obrigação desde que na mesma pessoa se \nconfundam as qualidades\
+    \ de credor e devedor. \n \nCom efeito, considerando que tanto a Defensoria Pública,\
+    \ quanto o seu Centro de \nEstudos Jurídicos são órgãos do próprio Estado, mostra-se\
+    \ flagrante que o caso é de confusão"
+  - "Poder Judiciário \nEstado do Rio de Janeiro \nDécima NonaCâmara Cível\n \n \n\
+    \ \n2 \nVOTO VENCIDO NA AC Nº  APELAÇÃO Nº 0337234-47.2014.8.19.0001 (3)\n \n\
+    \ \nNo mérito, sustenta a não-caracterização da apelada como \nentidade de assistência\
+    \ social, devendo ser aplicada a Súmula 730 do STF. \n \n Assevera, ainda a inexistência\
+    \ de comprovação dos \nrequisitos para gozo da imunidade previstos no art. 14\
+    \ do CTN.  \n \nAfirma que a decisão que revogou o reconhecimento da \nimunidade\
+    \ tributária da recorrida foi proferida em 1993 e os fatos geradores do \nISS\
+    \ que deram ensejo à ação de execução fiscal ocorreram entre maio de 1997 \naté\
+    \ abril de 2002, não havendo que se falar em retroatividade, pois o período \n\
+    cobrado na execução fiscal é bem posterior à decisão que revogou a concessão \n\
+    de imunidade tributária. \n \nDestaca que não há excesso de execução, pois o \n\
+    Município do Rio de Janeiro, ao reverso da União Federal, jamais vinculou seus\
+    \ \ncréditos tributários aos parâmetros da Taxa SELIC.  \n \nPor fim, que inexiste\
+    \ ilegalidade na cobrança das multas: \na multa punitiva prevista no artigo 51,\
+    \ é sanção aplicada pelo Fisco para coibir \na burla à atuação da administração\
+    \ tributária, a sanção tem caráter pedagógico. \nJá a multa moratória prevista\
+    \ no artigo 181 é multa pelo atraso no \ncumprimento da obrigação, bem assim,\
+    \ que o artigo 1° da Lei Municipal \n5.546/2012 não pode ser aplicado, pois os\
+    \ fatos geradores da execução fiscal \nem apenso ocorreram no período de 1997\
+    \ até abril de 2002. \n \nPois bem. \n \nAfasto a \npreliminar de nulidade\n ausência\
+    \ de intimação \npessoal do município para falar sobre os esclarecimentos do Perito\
+    \ ao laudo \ncrítico. \n \nCom efeito, \no Município se manifestou acerca do"
+  - "Atribuição: Fazenda Pública \nCódigo/Nome Movimento: 1000173/Outras manifestações\
+    \ em 2º grau\n \nrestituição dos valores indevidamente descontados, com atualização\
+    \ e juros, e \napuração em fase de liquidação de sentença.  \n \nInconformada,\
+    \ a parte ré interpôs o recurso de apelação do \nitem 000114. \n \nPetição juntada\
+    \ no item 000122 noticiando o falecimento do \nautor e requerendo sua substituição\
+    \ processual por sua filha, Luciana Maria da Silva \nMirandola. \n \nDespacho\
+    \ no item 000140 determinando a intimação da \nProcuradoria Geral do Município\
+    \ do Rio de Janeiro e do Ministério Público sobre o \npedido de habilitação. \n\
+    \ \nCiência do Parquet no item 000148. \n \nManifestação dos réus no item 000150\
+    \ requerendo a \ndeclaração de nulidade da sentença e dos atos praticados após\
+    \ o óbito do autor, bem \ncomo a rejeição do pedido de habilitação, uma vez que\
+    \ a sucessão processual deveria \nser pelo espólio, na forma do artigo 110 do\
+    \ CPC. \n \nDespacho no item 000155 para manifestação do Ministério \nPúblico.\
+    \ \n \nCiência do Parquet no item 000161. \n \nDespacho no item 000164 para manifestação\
+    \ da parte autora. \n \n221"
+pipeline_tag: sentence-similarity
+library_name: sentence-transformers
+metrics:
+- cosine_accuracy@1
+- cosine_accuracy@3
+- cosine_accuracy@5
+- cosine_accuracy@10
+- cosine_precision@1
+- cosine_precision@3
+- cosine_precision@5
+- cosine_precision@10
+- cosine_recall@1
+- cosine_recall@3
+- cosine_recall@5
+- cosine_recall@10
+- cosine_ndcg@10
+- cosine_mrr@10
+- cosine_map@100
+model-index:
+- name: SentenceTransformer based on Alibaba-NLP/gte-multilingual-base
+  results:
+  - task:
+      type: information-retrieval
+      name: Information Retrieval
+    dataset:
+      name: Unknown
+      type: unknown
+    metrics:
+    - type: cosine_accuracy@1
+      value: 0.6545
+      name: Cosine Accuracy@1
+    - type: cosine_accuracy@3
+      value: 0.7925
+      name: Cosine Accuracy@3
+    - type: cosine_accuracy@5
+      value: 0.841
+      name: Cosine Accuracy@5
+    - type: cosine_accuracy@10
+      value: 0.89
+      name: Cosine Accuracy@10
+    - type: cosine_precision@1
+      value: 0.6545
+      name: Cosine Precision@1
+    - type: cosine_precision@3
+      value: 0.5031666666666667
+      name: Cosine Precision@3
+    - type: cosine_precision@5
+      value: 0.4011
+      name: Cosine Precision@5
+    - type: cosine_precision@10
+      value: 0.27425
+      name: Cosine Precision@10
+    - type: cosine_recall@1
+      value: 0.23852962917260728
+      name: Cosine Recall@1
+    - type: cosine_recall@3
+      value: 0.4422107764041644
+      name: Cosine Recall@3
+    - type: cosine_recall@5
+      value: 0.5245186089315591
+      name: Cosine Recall@5
+    - type: cosine_recall@10
+      value: 0.6212349911293668
+      name: Cosine Recall@10
+    - type: cosine_ndcg@10
+      value: 0.6220169640997574
+      name: Cosine Ndcg@10
+    - type: cosine_mrr@10
+      value: 0.7325833333333327
+      name: Cosine Mrr@10
+    - type: cosine_map@100
+      value: 0.5411107394124216
+      name: Cosine Map@100
+---
+
+# SentenceTransformer based on Alibaba-NLP/gte-multilingual-base
+
+This is a [sentence-transformers](https://www.SBERT.net) model finetuned from [Alibaba-NLP/gte-multilingual-base](https://huggingface.co/Alibaba-NLP/gte-multilingual-base) on the parquet dataset. 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:** [Alibaba-NLP/gte-multilingual-base](https://huggingface.co/Alibaba-NLP/gte-multilingual-base) <!-- at revision 9bbca17d9273fd0d03d5725c7a4b0f6b45142062 -->
+- **Maximum Sequence Length:** 8192 tokens
+- **Output Dimensionality:** 768 dimensions
+- **Similarity Function:** Cosine Similarity
+- **Training Dataset:**
+    - parquet
+<!-- - **Language:** Unknown -->
+<!-- - **License:** Unknown -->
+
+### Model Sources
+
+- **Documentation:** [Sentence Transformers Documentation](https://sbert.net)
+- **Repository:** [Sentence Transformers on GitHub](https://github.com/huggingface/sentence-transformers)
+- **Hugging Face:** [Sentence Transformers on Hugging Face](https://huggingface.co/models?library=sentence-transformers)
+
+### Full Model Architecture
+
+```
+SentenceTransformer(
+  (0): Transformer({'max_seq_length': 8192, 'do_lower_case': False, 'architecture': 'NewModel'})
+  (1): Pooling({'word_embedding_dimension': 768, 'pooling_mode_cls_token': True, 'pooling_mode_mean_tokens': False, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
+  (2): Normalize()
+)
+```
+
+## 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("sentence_transformers_model_id")
+# Run inference
+sentences = [
+    'PROCURADORIA GERAL DO ESTADO DO RIO DE JANEIRO \nPROCURADORIA DE SERVIÇOS DE SAÚDE (PG-16) \n \nEXMO. SR. DR. DES. 3º PRESIDENTE DO TRIBUNAL DE JUSTIÇA DO RIO DE \nJANEIRO \n \n \n \nProcesso 0076107-19.2019.8.19.0001 \n \n \n \nO\n ESTADO DO RIO DE JANEIRO, \npela Procuradoria Geral do Estado, \nnos autos do recurso extraordinário interposto por \nPERCEDINA DOS SANTOS TORRES e \noutro\n,\n \nvem, tempestivamente, apresentar suas \n \n \nCONTRARRAZÕES DE RECURSO EXTRAORDINÁRIO \n \n \npelos fundamentos jurídicos expostos na peça em anexo, esperando, desde já, pelo não \nconhecimento ou pelo desprovimento do recurso, como de Direito. \n \nPede deferimento. \nRio de Janeiro, 26 de janeiro de 2021.  \n \n \n \nLETICIA LACROIX DE OLIVEIRA \nP\nROCURADORA DO \nE\nSTADO\n \n \n \n \n \n \n \nTJRJ 202100041683 27/01/2021 00:06:00 GPLI - PETIÇÃO ELETRÔNICA Assinada por LETICIA LACROIX DE OLIVEIRA\n373\nDigitally signed by LETICIA LACROIX DE OLIVEIRA:04296848780\nDate: 2021.01.26 21:23:08 BRST',
+    'PROCURADORIA GERAL DO ESTADO DO RIO DE JANEIRO \nPROCURADORIA DE SERVIÇOS DE SAÚDE (PG-16) \n \n \n3 \n \n          Na prática, pode-se concluir que o acórdão recorrido revogou toda a \njurisprudência sumular dos Tribunais Superiores, entendendo ser aplicável um julgado do STF \nque, numa ação rescisória e em caráter incidental, acredita ser cabível o pagamento de \nhonorários advocatícios à Defensoria Pública pelo mesmo ente federado responsável por seu \nfuncionamento. Situação que, \npermissa venia\n, é inadmissível e viola frontalmente o \nordenamento jurídico vigente. \n \n         Uma outra questão jurídica diz respeito à possibilidade de este acórdão do STF, \nque como já se disse, decidiu sobre o tema em caráter incidental e não tem caráter vinculante, \nrevogar a própria Súmula 421 do STJ. Um acórdão que decide um tema de modo incidental \nrevoga automaticamente as Súmulas dos outros Tribunais? \nData venia\n, parece-nos que não.  \n \nII - ILEGALIDADE DO PAGAMENTO DE HONORÁRIOS PELO ESTADO EM \nFAVOR DA DEFENSORIA PÚBLICA – OCORRÊNCIA DA CONFUSÃO (ARTIGO \n381 DO CÓDIGO CIVIL) – TEMA PACIFICADO PELO E. STJ\n \n  \nRememore-se, por oportuno, que já está pacificado na doutrina e na jurisprudência \no entendimento de que há confusão na condenação do Estado ao pagamento de honorários \nsucumbenciais à Defensoria Pública, nos termos do que estabelece o artigo 381 do Código Civil, \nverbis\n: \n \nArt. 381 – Extingue-se a obrigação desde que na mesma pessoa se \nconfundam as qualidades de credor e devedor. \n \nCom efeito, considerando que tanto a Defensoria Pública, quanto o seu Centro de \nEstudos Jurídicos são órgãos do próprio Estado, mostra-se flagrante que o caso é de confusão',
+    'Atribuição: Fazenda Pública \nCódigo/Nome Movimento: 1000173/Outras manifestações em 2º grau\n \nrestituição dos valores indevidamente descontados, com atualização e juros, e \napuração em fase de liquidação de sentença.  \n \nInconformada, a parte ré interpôs o recurso de apelação do \nitem 000114. \n \nPetição juntada no item 000122 noticiando o falecimento do \nautor e requerendo sua substituição processual por sua filha, Luciana Maria da Silva \nMirandola. \n \nDespacho no item 000140 determinando a intimação da \nProcuradoria Geral do Município do Rio de Janeiro e do Ministério Público sobre o \npedido de habilitação. \n \nCiência do Parquet no item 000148. \n \nManifestação dos réus no item 000150 requerendo a \ndeclaração de nulidade da sentença e dos atos praticados após o óbito do autor, bem \ncomo a rejeição do pedido de habilitação, uma vez que a sucessão processual deveria \nser pelo espólio, na forma do artigo 110 do CPC. \n \nDespacho no item 000155 para manifestação do Ministério \nPúblico. \n \nCiência do Parquet no item 000161. \n \nDespacho no item 000164 para manifestação da parte autora. \n \n221',
+]
+embeddings = model.encode(sentences)
+print(embeddings.shape)
+# [3, 768]
+
+# Get the similarity scores for the embeddings
+similarities = model.similarity(embeddings, embeddings)
+print(similarities)
+# tensor([[ 1.0000,  0.6637, -0.0623],
+#         [ 0.6637,  1.0000, -0.0069],
+#         [-0.0623, -0.0069,  1.0000]])
+```
+
+<!--
+### 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
+
+#### Information Retrieval
+
+* Evaluated with [<code>InformationRetrievalEvaluator</code>](https://sbert.net/docs/package_reference/sentence_transformer/evaluation.html#sentence_transformers.evaluation.InformationRetrievalEvaluator)
+
+| Metric              | Value     |
+|:--------------------|:----------|
+| cosine_accuracy@1   | 0.6545    |
+| cosine_accuracy@3   | 0.7925    |
+| cosine_accuracy@5   | 0.841     |
+| cosine_accuracy@10  | 0.89      |
+| cosine_precision@1  | 0.6545    |
+| cosine_precision@3  | 0.5032    |
+| cosine_precision@5  | 0.4011    |
+| cosine_precision@10 | 0.2742    |
+| cosine_recall@1     | 0.2385    |
+| cosine_recall@3     | 0.4422    |
+| cosine_recall@5     | 0.5245    |
+| cosine_recall@10    | 0.6212    |
+| **cosine_ndcg@10**  | **0.622** |
+| cosine_mrr@10       | 0.7326    |
+| cosine_map@100      | 0.5411    |
+
+<!--
+## 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 Dataset
+
+#### parquet
+
+* Dataset: parquet
+* Size: 200,000 training samples
+* Columns: <code>anchor</code> and <code>positive</code>
+* Approximate statistics based on the first 1000 samples:
+  |         | anchor                                                                                | positive                                                                            |
+  |:--------|:--------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|
+  | type    | string                                                                                | string                                                                              |
+  | details | <ul><li>min: 129 tokens</li><li>mean: 395.23 tokens</li><li>max: 490 tokens</li></ul> | <ul><li>min: 99 tokens</li><li>mean: 356.9 tokens</li><li>max: 509 tokens</li></ul> |
+* Samples:
+  | anchor                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | positive                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+  |:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+  | <code>Doc. 1 <br>TJRJ CAP 12VFE 202401831853 17/04/24 12:55:57139829 PROGER-VIRTUAL<br>54<br><br><br>Petição Inicial Eletrônica 2ª instância/Conselho da Magistratura<br> <br>Srº Usuário, a petição foi encaminhada com sucesso.<br> <br>O protocolo gerado é a sua garantia do recebimento da petição pelo Tribunal de Justiça do<br>Rio de Janeiro, sendo desnecessário novo peticionamento eletrônico com as mesmas<br>informações.<br> <br>Dados do Processo<br>Processo: 0028612-06.2024.8.19.0000<br> <br>Protocolo: 3204/2024.00310040<br> <br>Segunda Instância<br> <br>Advogado(s)<br>  <br>RJ144016<br> - DANIEL NEVES ROSA DURÃO DE ANDRADE<br>RJ152461<br> - CAROLINA TEIXEIRA DE SOUSA<br>  <br>Parte(s)<br>  <br>PASQUALE MAURO BENF<br> , Pessoa Física , CPF - 007.220.147-91 Endereço: Comercial - das Américas, 10333,<br>RJ, Rio de Janeiro, Barra da Tijuca, , CEP: 22793082<br>  <br>Documento(s)<br>Data : 16/04/2024<br>Horário : 17:55<br>Número do Processo de Referência: <br>10041723<br>Orgão de Origem: <br>Capital: Cartório Eletrônico da 12ª Vara de Fazenda Publica<br>Natureza: <br>Civel<br>Tipo Protocolo: <br>AGRAVO DE INSTRUMENTO - CÍV...</code> | <code>3 <br>5.172/1966 – Código Tributário Nacional – “CTN”, com sua redação anterior à Lei Complementar <br>nº 118, de 9 de fevereiro de 2005. <br> <br>Em que pese a robusta argumentação contida da referida Exceção, esta foi rejeitada <br>por intermédio da r. decisão do indexador nº 28, ora agravada, abaixo transcrita: <br> <br>“Reconsidero a decisão retro equivocadamente proferida visto que o executado se encontra <br>representado nos autos por advogado. <br>Rejeito a arguição de prescrição visto que<br> <br>consta do Sistema de Dívida Ativa bem como <br>deste E. Tribunal de justiça que o AR para citação do executado retornou com <br>resultado positivo<br>. <br>Lavre-se termo de penhora e intime-se na forma do art. 12 da LEF”. (grifamos) <br> <br>Data maxima venia<br>, a conclusão exarada pelo MM. Juízo <br>a quo<br> não observa a legislação <br>e jurisprudência relativa ao reconhecimento da prescrição originária e intercorrente, se justificando a <br>interposição do presente Agravo de Instrumento com o intuito de obter a reforma da r. decisão <br>recorrida...</code> |
+  | <code>TRIBUNAL DE JUSTIÇA DO RIO DE JANEIRO<br>eJUD TJRJ<br>03/05/2021 06:52<br>Emitido em:<br>DGJUR - SECRETARIA DA 12ª CÂMARA CÍVEL<br>Processo: 0277899-58.2018.8.19.0001 - APELAÇÃO<br>INTIMAÇÃO ELETRÔNICA<br>Rio de Janeiro, 03 de maio de  2021<br>Fica V. Sª / V. Exª intimado da determinação abaixo:<br>DÉCIMA SEGUNDA CÂMARA CÍVEL<br>DÉCIMA SEGUNDA CÂMARA CÍVEL<br>EMBARGOS DE DECLARAÇÃO EM APELAÇÃO CÍVEL Nº 0277899-58.2018.8.19.0001<br>EMBARGOS DE<br>Embargantes 1: JANE PASQUINELLI E OUTROS.<br>Embargantes 1: JANE PASQUINELLI E OUTROS.<br>Embargantes 2:  PREVI-RIO - INSTITUTO DE PREVIDÊNCIA E ASSISTÊNCIA.<br>Embargantes 2:  PREVI-RIO<br>Embargados: OS MESMOS<br>Embargados: OS MESMOS<br>Relator: Desembargador JAIME DIAS PINHEIRO FILHO<br>Relator: Desembargador JAIME DIAS PINHEIRO <br>EMBARGOS DE DECLARAÇÃO OPOSTOS POR AMBAS AS PARTES. EMBARGOS OPOSTOS PELOS<br>EMBA<br>AUTORES/EMBARGANTES, QUE DEVE SER PROVIDO, COM EFEITOS INFRINGENTES, A FIM DE<br>AUTO<br>QUE O RÉU REEMBOLSE AOS AUTORES AS CUSTAS E A TAXA JUDICIÁRIA QUE FORAM<br>QUE O<br>ANTECIPADAS PELOS AUTORES, ANTE O...</code>                                                 | <code>não concorda e deve, por isso, manejar os recursos que entender cabíveis e não insistir na oposição de embargos<br>que, em regra, não servem para alterar o julgado, notadamente quando não há omissão, contradição, obscuridade<br>ou erro material.<br>            In casu, o que se extrai dos autos é que os presentes embargos visam, primordialmente, a reforma, bem<br>como o prequestionamento da matéria objeto do julgado, conforme consignado em suas razões, ocasião em que a<br>recorrente pleiteia, inclusive, a concessão de efeitos infringentes.<br>         Como é cediço, a modificação do julgado não se insere entre as funções dos embargos de declaração, o que<br>só se admite em casos excepcionais, não sendo, pois, esta a hipótese dos autos.<br>         A propósito, transcrevo trecho do julgamento de Embargos de Declaração, da lavra do eminente Professor e<br>Desembargador Sergio Cavalieri Filho:<br>"Embargos de Declaração. Omissão Inexistente. Contestação do Julgado. Efeito Modificativo. Prequestionamento.<br>Descabimento....</code>                                     |
+  | <code>TRIBUNAL DE JUSTIÇA DO ESTADO DO RIO DE JANEIRO<br>eJUD TJRJ<br>08/03/2024 12:11<br>Emitido em:<br>SECRETARIA DA 6ª CÂMARA DE DIREITO PÚBLICO (ANTIGA 21ª CÂMARA CÍVEL)<br>Processo: 0297157-30.2013.8.19.0001 - APELAÇÃO<br>INTIMAÇÃO ELETRÔNICA<br>Rio de Janeiro, 08 de março de  2024<br>Fica V. Sª / V. Exª intimado da determinação abaixo:<br>Apelação Cível nº 0297157-30.2013.8.19.0001<br>Apelante: INSTITUTO DE PREVIDÊNCIA E ASSISTÊNCIA DO MUNICÍPIO DO RIO DE JANEIRO -<br>PREVIRIO<br>Apelado: MIDAS ENGENHARIA LTDA<br>Juízo de Origem: Quinta Vara de Fazenda Pública da Comarca da Capital<br>Relatora: Desembargadora LIDIA MARIA SODRÉ DE MORAES<br>APELAÇÃO CÍVEL. DIREITO ADMINISTRATIVO. AÇÃO DE OBRIGAÇÃO DE FAZER. PRESTAÇÃO DE<br>SERVIÇO. ALEGAÇÃO AUTORAL DE INEXECUÇÃO PARCIAL DO CONTRATO DE PRESTAÇÃO DE<br>SERVIÇOS COM EXECUÇÃO DE OBRAS DO SISTEMA DE AR-CONDICIONADO NOS BLOCOS I E II<br>DO CENTRO ADMINISTRATIVO SÃO SEBASTIÃO. SENTENÇA QUE JULGOU IMPROCEDENTE O<br>PEDIDO. IRRESIGNAÇÃO DO INSTITUTO DE PREVIDÊNCIA REPRISANDO AS ARGUMENTAÇÕES<br>APRESENTA...</code>                                                                      | <code>Requereu a procedência do pedido para a condenação da ré na    obrigação de fazer consistente na adequada<br>instalação do sistema de automação e "telesupervisão" do ar condicionado, ou subsidiariamente, a conversão em<br>perdas e danos, desde, 26/06/2008, término   do prazo  para    cumprimento    do  contrato,  e    ao    pagamento    <br>de    danos    materiais  relativo  aos  juros   compensatórios  e  de  mora,  com  correção  monetária,  desde  o  <br>desembolso  e  de  acordo  com  as taxas contratualmente previstas, em razão do inadimplemento parcial do<br>contrato.<br>          Adoto, no mais, o relatório constante da sentença, na forma regimental.<br>          Prestação jurisdicional através da prolação da sentença de índice 430, que julgou improcedente o pedido,<br>cuja parte dispositiva, reza o seguinte:<br>"...Isto posto, julgo improcedentes os pedidos, e, em consequência, extinto o processo com julgamento do mérito,<br>na forma do artigo 487, I, do Código de Processo Civil.<br>Condeno a parte autora ao ...</code>                                     |
+* Loss: [<code>MultipleNegativesRankingLoss</code>](https://sbert.net/docs/package_reference/sentence_transformer/losses.html#multiplenegativesrankingloss) with these parameters:
+  ```json
+  {
+      "scale": 20.0,
+      "similarity_fct": "cos_sim",
+      "gather_across_devices": false
+  }
+  ```
+
+### Evaluation Dataset
+
+#### parquet
+
+* Dataset: parquet
+* Size: 2,000 evaluation samples
+* Columns: <code>anchor</code> and <code>positive</code>
+* Approximate statistics based on the first 1000 samples:
+  |         | anchor                                                                                | positive                                                                             |
+  |:--------|:--------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|
+  | type    | string                                                                                | string                                                                               |
+  | details | <ul><li>min: 112 tokens</li><li>mean: 392.22 tokens</li><li>max: 536 tokens</li></ul> | <ul><li>min: 98 tokens</li><li>mean: 354.08 tokens</li><li>max: 555 tokens</li></ul> |
+* Samples:
+  | anchor                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | positive                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+  |:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+  | <code>EXCELENTÍSSIMA. DRA. DESEMBARGADORA-RELATORA DA QUINTA <br>CÂMARA DE DIREITO PÚBLICO DO TRIBUNAL DE JUSTIÇA DO ESTADO DO <br>RIO DE JANEIRO. <br> <br>Apelação Cível nº 0145575-65.2022.8.19.0001<br> <br> <br> <br> <br>SUZANA DE FÁTIMA DE SOUZA SILVA,<br> embargante já <br>devidamente qualificada nos autos do processo acima epigrafado, <br>VEM<br> <br>tempestivamente no quinquídio legal, e respeitosamente à presença de Vossa <br>Excelência, nos termos do art. 1.022, 1023 e 1.025 do Novo CPC, opor <br> <br>EMBARGOS DE DECLARAÇÃO <br>COM EFEITOS DE PREQUESTIONAMENTO E SUPERAÇÃO DE OMISSÃO <br>(SÚMULAS 98 E 211 DO STJ) <br> <br> <br>em face da decisão do acórdão proferido nos presentes autos em <br>epígrafe, que improveu a apelação das embargantes, para suprir pontos <br>contraditórios, proferido nos presentes autos em epígrafe, e a inda clarear <br>obscuridade, e afastar omissões, que eventualmente se registrem no V. Acórdão, <br>com base nos seguintes fundamentos fáticos e jurídicos a serem expostos a seguir:<br> <br>Nesse passo, e por isso, no entender da embargante, há...</code>                      | <code>Escolar; Dar banho e trocar o vestuário das crianças da <br>creche; Auxiliar na orientação das crianças no recreio <br>e nos intervalos, objetivando manter a segurança e a <br>disciplina; Participar de todas as aulas prestando <br>todos os cuidados devido às crianças; Organizar o <br>ambiente e orientar as crianças para o repouso, <br>permanecendo com elas durante todo o tempo que <br>estiverem <br>dormindo; <br>Responsabilizar-se <br>pelas <br>crianças que aguardam os pais ou o transporte escolar <br>até a sua efetiva entrega, zelando pela segurança e <br>bem estar de todos; Responsabilizar-se pela limpeza e <br>desinfecção de brinquedos e equipamentos utilizados <br>pelas crianças; Participar de todas as atividades <br>576</code>                                                                                                                                                                                                                                                                                                                                                |
+  | <code>TRIBUNAL DE JUSTIÇA DO RIO DE JANEIRO<br>eJUD TJRJ<br>03/08/2021 14:39<br>Emitido em:<br>DGJUR - SECRETARIA DA 22ª CÂMARA CÍVEL<br>Processo: 0232479-93.2019.8.19.0001 - APELAÇÃO<br>INTIMAÇÃO ELETRÔNICA<br>Rio de Janeiro, 03 de agosto de  2021<br>Fica V. Sª / V. Exª intimado da determinação abaixo:<br>VIGÉSIMA SEGUNDA CÂMARA CÍVEL<br>APELAÇÃO CÍVEL Nº 0232479-93.2019.8.19.0001<br>APELANTE 1: MUNICÍPIO DO RIO DE JANEIRO <br>PROC. MUNICIPAL: LEO BOSCO GRIGGI PEDROSA <br>APELANTE 2 : ESTADO DO RIO DE JANEIRO <br>PROC. DO ESTADO: ANA CRISTINA BACOS <br>APELADO : ASSOCIAÇÃO LAR SÃO FRANCISCO DE ASSIS NA PROVIDÊNCIA DE DEUS <br>ADVOGADO : PAMELA GUIMARÃES TEIXEIRA LIMA<br>RELATOR: DES. BENEDICTO ABICAIR<br>APELAÇÃO CÍVEL. ÇÃO DE COBRANÇA PROPOSTA POR HOSPITAL DA REDE PRIVADA EM FACE<br>DO ESTADO DO RIO DE JANEIRO E DO MUNICÍPIO DO RIO DE JANEIRO. DESPESAS DECORRENTES<br>DE INTERNAÇÃO E TRATAMENTO DE PACIENTE IMPOSTA POR DECISÃO JUDICIAL. OBRIGAÇÃO<br>SOLIDÁRIA DOS ENTES PÚBLICOS QUANTO À COBERTURA DOS CUSTOS DO TRATAMENTO.<br>ILEGITIMIDADE PASSIVA QUE SE AF...</code>                                        | <code>VEREDA, A PRESTAÇÃO DO SERVIÇO MÉDICO-HOSPITALAR PELO AUTOR DECORREU DA<br>OMISSÃO DO PODER PÚBLICO EM CUMPRIR COM O SEU DEVER CONSTITUCIONAL,<br>CABENDO-LHE, POR CONSEGUINTE, RESSARCIR OS GASTOS SUPORTADOS PELO HOSPITAL<br>PARTICULAR. NO QUE SE REFERE À LIMITAÇÃO DO RESSARCIMENTO À TABELA DO SISTEMA<br>ÚNICO DE SAÚDE, O INTENTO RECURSAL NÃO MERECE PROSPERAR, NA MEDIDA EM QUE O<br>HOSPITAL AUTOR NÃO POSSUI CONVÊNIO COM O SUS. POR OUTRO LADO, NÃO SE MOSTRA<br>RAZOÁVEL EXIGIR QUE HOSPITAL PARTICULAR SUPORTE OS GASTOS, AINDA QUE<br>PARCIALMENTE, PARA INTERNAÇÃO E TRATAMENTO DE ADMINISTRADO EM RAZÃO DA<br>OMISSÃO DO ENTE PÚBLICO E EM DECORRÊNCIA DE DECISÃO JUDICIAL. DESPROVIMENTO DOS<br>RECURSOS. SENTENÇA MANTIDA<br>0140919-75.2016.8.19.0001 - Apelação - Relator: Des(a). MÔNICA DE FARIA SARDAS - Data de Julgamento:<br>06/08/2020, VIGÉSIMA CÂMARA CÍVEL <br>APELAÇÃO CÍVEL. AÇÃO DE COBRANÇA PROPOSTA POR HOSPITAL DA REDE PRIVADA EM FACE<br>DO ESTADO DO RIO DE JANEIRO E DO MUNICÍPIO DO RIO DE JANEIRO. DESPESAS DECORRENTES<br>274</code>                                   |
+  | <code>Praça Floriano, n. 55, sala 409 – Cinelândia - Centro. Rio de Janeiro – RJ. Brasil. CEP: 20.031-050. <br>Tel: (21) 2533-6008   [email protected]   www.simonatopessoa.adv.br  <br> <br>EXCELENTÍSSIMO SENHOR DOUTOR DESEMBARGADOR TERCEIRO <br>VICE-PRESIDENTE EDSON VASCONCELOS DO TRIBUNAL DE JUSTIÇA <br>DO ESTADO DO RIO DE JANEIRO. <br> <br>RECURSO ESPECIAL Nº 0466091-77.2015.8.19.0001<br> <br>Relator: <br>DES. MARCOS ANDRÉ CHUT  <br>Apelante: <br>INSTITUTO SAO JOAO BATISTA LTDA - ISJOB <br>Apelado: <br>MUNICÍPIO DO RIO DE JANEIRO <br> <br>GRATUIDADE DE JUSTIÇA <br> <br> <br> <br> <br> <br>INSTITUTO SÃO JOÃO BAPTISTA LTDA – ISJOB<br>, com sede na Rua <br>Medina, 246, Méier, Rio de Janeiro – RJ. CEP: 20.735-130, inscrito no CNPJ/MF <br>sob nº 33.666.306/0001-30, nos autos do recurso de <br>Apelação<br> em epigrafe que <br>move em face do<br> MUNICÍPIO DO RIO DE JANEIRO<br>, por seu advogado, vem <br>respeitosamente à presença de Vossa Excelência, inconformado com a decisão <br>que inadmitiu o <br>RECUSOS ESPECIAL<br>, da lavra do Ilustre Desembargador <br>Terceiro Vice-Presi...</code> | <code>Praça Floriano, n. 55, sala 409 – Cinelândia - Centro. Rio de Janeiro – RJ. Brasil. CEP: 20.031-050. <br>Tel: (21) 2533-6008   [email protected]   www.simonatopessoa.adv.br  <br> <br>69. Assim, a partir do confronto destas datas não restam dúvidas de que as <br>obrigações em questão já se encontravam extintas. <br> <br>70. Neste sentido, resta evidente que a cobrança dos créditos tributários ora <br>contestados, encontra-se prescrita nos termos do caput do artigo 174 do <br>Código Tributário Nacional – CTN conforme o entendimento já <br>consolidado pelo Superior Tribunal de Justiça, conforme ementa abaixo <br>transcrita: <br> <br>“0010513-72.2004.8.19.0037 - APELACAO  <br> <br>1ª Ementa <br>DES. JACQUELINE MONTENEGRO - Julgamento: 15/10/2015 - DECIMA <br>QUINTA CAMARA CIVEL  <br> <br>APELAÇÃO CÍVEL. PROCESSUAL CIVIL. EXECUÇÃO FISCAL. IMPOSTO <br>SOBRE PROPRIEDADE TERRITORIAL URBANA ¿ IPTU, TAXA DE <br>SERVIÇOS URBANOS ¿ TSU E TAXA DE COLETA DE LIXO DOMICILIAR ¿ <br>TCDL DOS EXERCÍCIOS DE 1999 A 2003. MANDADO DE CITAÇÃO EM <br>EXEC...</code> |
+* Loss: [<code>MultipleNegativesRankingLoss</code>](https://sbert.net/docs/package_reference/sentence_transformer/losses.html#multiplenegativesrankingloss) with these parameters:
+  ```json
+  {
+      "scale": 20.0,
+      "similarity_fct": "cos_sim",
+      "gather_across_devices": false
+  }
+  ```
+
+### Training Hyperparameters
+#### Non-Default Hyperparameters
+
+- `eval_strategy`: steps
+- `per_device_train_batch_size`: 64
+- `per_device_eval_batch_size`: 64
+- `gradient_accumulation_steps`: 4
+- `num_train_epochs`: 1
+- `warmup_ratio`: 0.1
+- `bf16`: True
+- `optim`: adamw_8bit
+- `gradient_checkpointing`: True
+- `eval_on_start`: 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`: 64
+- `per_device_eval_batch_size`: 64
+- `per_gpu_train_batch_size`: None
+- `per_gpu_eval_batch_size`: None
+- `gradient_accumulation_steps`: 4
+- `eval_accumulation_steps`: None
+- `torch_empty_cache_steps`: None
+- `learning_rate`: 5e-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`: 1
+- `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`: True
+- `fp16`: False
+- `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`: {'min_num_params': 0, 'xla': False, 'xla_fsdp_v2': False, 'xla_fsdp_grad_ckpt': False}
+- `fsdp_transformer_layer_cls_to_wrap`: None
+- `accelerator_config`: {'split_batches': False, 'dispatch_batches': None, 'even_batches': True, 'use_seedable_sampler': True, 'non_blocking': False, 'gradient_accumulation_kwargs': None}
+- `parallelism_config`: None
+- `deepspeed`: None
+- `label_smoothing_factor`: 0.0
+- `optim`: adamw_8bit
+- `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`: None
+- `hub_always_push`: False
+- `hub_revision`: None
+- `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
+- `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`: True
+- `use_liger_kernel`: False
+- `liger_kernel_config`: None
+- `eval_use_gather_object`: False
+- `average_tokens_across_devices`: False
+- `prompts`: None
+- `batch_sampler`: no_duplicates
+- `multi_dataset_batch_sampler`: proportional
+- `router_mapping`: {}
+- `learning_rate_mapping`: {}
+
+</details>
+
+### Training Logs
+| Epoch  | Step | Training Loss | Validation Loss | cosine_ndcg@10 |
+|:------:|:----:|:-------------:|:---------------:|:--------------:|
+| 0      | 0    | -             | 2.9505          | 0.1959         |
+| 0.1011 | 79   | 1.7256        | 0.8699          | 0.4472         |
+| 0.2022 | 158  | 0.8044        | 0.6145          | 0.5072         |
+| 0.3034 | 237  | 0.6254        | 0.5068          | 0.5353         |
+| 0.4045 | 316  | 0.5215        | 0.4230          | 0.5725         |
+| 0.5056 | 395  | 0.4507        | 0.3787          | 0.5906         |
+| 0.6067 | 474  | 0.4014        | 0.3429          | 0.6014         |
+| 0.7078 | 553  | 0.3779        | 0.3279          | 0.6129         |
+| 0.8090 | 632  | 0.3463        | 0.3099          | 0.6223         |
+| 0.9101 | 711  | 0.3202        | 0.2974          | 0.6220         |
+
+
+### Framework Versions
+- Python: 3.12.11
+- Sentence Transformers: 5.1.2
+- Transformers: 4.57.0.dev0
+- PyTorch: 2.9.0+cu128
+- Accelerate: 1.11.0
+- Datasets: 4.3.0
+- Tokenizers: 0.22.1
+
+## 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",
+}
+```
+
+#### MultipleNegativesRankingLoss
+```bibtex
+@misc{henderson2017efficient,
+    title={Efficient Natural Language Response Suggestion for Smart Reply},
+    author={Matthew Henderson and Rami Al-Rfou and Brian Strope and Yun-hsuan Sung and Laszlo Lukacs and Ruiqi Guo and Sanjiv Kumar and Balint Miklos and Ray Kurzweil},
+    year={2017},
+    eprint={1705.00652},
+    archivePrefix={arXiv},
+    primaryClass={cs.CL}
+}
+```
+
+<!--
+## 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.*
+-->

config.json

@@ -0,0 +1,49 @@
+{
+  "architectures": [
+    "NewModel"
+  ],
+  "attention_probs_dropout_prob": 0.0,
+  "auto_map": {
+    "AutoConfig": "configuration.NewConfig",
+    "AutoModel": "modeling.NewModel",
+    "AutoModelForMaskedLM": "Alibaba-NLP/new-impl--modeling.NewForMaskedLM",
+    "AutoModelForMultipleChoice": "Alibaba-NLP/new-impl--modeling.NewForMultipleChoice",
+    "AutoModelForQuestionAnswering": "Alibaba-NLP/new-impl--modeling.NewForQuestionAnswering",
+    "AutoModelForSequenceClassification": "Alibaba-NLP/new-impl--modeling.NewForSequenceClassification",
+    "AutoModelForTokenClassification": "Alibaba-NLP/new-impl--modeling.NewForTokenClassification"
+  },
+  "classifier_dropout": 0.0,
+  "dtype": "float32",
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "id2label": {
+    "0": "LABEL_0"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "label2id": {
+    "LABEL_0": 0
+  },
+  "layer_norm_eps": 1e-12,
+  "layer_norm_type": "layer_norm",
+  "logn_attention_clip1": false,
+  "logn_attention_scale": false,
+  "max_position_embeddings": 8192,
+  "model_type": "new",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "pack_qkv": true,
+  "pad_token_id": 1,
+  "position_embedding_type": "rope",
+  "rope_scaling": {
+    "factor": 8.0,
+    "type": "ntk"
+  },
+  "rope_theta": 20000,
+  "transformers_version": "4.57.0.dev0",
+  "type_vocab_size": 1,
+  "unpad_inputs": false,
+  "use_memory_efficient_attention": false,
+  "vocab_size": 250048
+}

config_sentence_transformers.json

@@ -0,0 +1,14 @@
+{
+  "model_type": "SentenceTransformer",
+  "__version__": {
+    "sentence_transformers": "5.1.2",
+    "transformers": "4.57.0.dev0",
+    "pytorch": "2.9.0+cu128"
+  },
+  "prompts": {
+    "query": "",
+    "document": ""
+  },
+  "default_prompt_name": null,
+  "similarity_fn_name": "cosine"
+}

configuration.py

@@ -0,0 +1,145 @@
+# coding=utf-8
+# Copyright 2024 The GTE Team Authors and Alibaba Group.
+# Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""" NEW model configuration"""
+from transformers.configuration_utils import PretrainedConfig
+from transformers.utils import logging
+
+logger = logging.get_logger(__name__)
+
+
+class NewConfig(PretrainedConfig):
+    r"""
+    This is the configuration class to store the configuration of a [`NewModel`] or a [`TFNewModel`]. It is used to
+    instantiate a NEW model according to the specified arguments, defining the model architecture. Instantiating a
+    configuration with the defaults will yield a similar configuration to that of the NEW
+    [izhx/new-base-en](https://huggingface.co/izhx/new-base-en) architecture.
+
+    Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
+    documentation from [`PretrainedConfig`] for more information.
+
+
+    Args:
+        vocab_size (`int`, *optional*, defaults to 30522):
+            Vocabulary size of the NEW model. Defines the number of different tokens that can be represented by the
+            `inputs_ids` passed when calling [`NewModel`] or [`TFNewModel`].
+        hidden_size (`int`, *optional*, defaults to 768):
+            Dimensionality of the encoder layers and the pooler layer.
+        num_hidden_layers (`int`, *optional*, defaults to 12):
+            Number of hidden layers in the Transformer encoder.
+        num_attention_heads (`int`, *optional*, defaults to 12):
+            Number of attention heads for each attention layer in the Transformer encoder.
+        intermediate_size (`int`, *optional*, defaults to 3072):
+            Dimensionality of the "intermediate" (often named feed-forward) layer in the Transformer encoder.
+        hidden_act (`str` or `Callable`, *optional*, defaults to `"gelu"`):
+            The non-linear activation function (function or string) in the encoder and pooler. If string, `"gelu"`,
+            `"relu"`, `"silu"` and `"gelu_new"` are supported.
+        hidden_dropout_prob (`float`, *optional*, defaults to 0.1):
+            The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.
+        attention_probs_dropout_prob (`float`, *optional*, defaults to 0.1):
+            The dropout ratio for the attention probabilities.
+        max_position_embeddings (`int`, *optional*, defaults to 512):
+            The maximum sequence length that this model might ever be used with. Typically set this to something large
+            just in case (e.g., 512 or 1024 or 2048).
+        type_vocab_size (`int`, *optional*, defaults to 2):
+            The vocabulary size of the `token_type_ids` passed when calling [`NewModel`] or [`TFNewModel`].
+        initializer_range (`float`, *optional*, defaults to 0.02):
+            The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
+        layer_norm_eps (`float`, *optional*, defaults to 1e-12):
+            The epsilon used by the layer normalization layers.
+        position_embedding_type (`str`, *optional*, defaults to `"rope"`):
+            Type of position embedding. Choose one of `"absolute"`, `"rope"`.
+        rope_theta (`float`, *optional*, defaults to 10000.0):
+            The base period of the RoPE embeddings.
+        rope_scaling (`Dict`, *optional*):
+            Dictionary containing the scaling configuration for the RoPE embeddings. Currently supports two scaling
+            strategies: linear and dynamic. Their scaling factor must be a float greater than 1. The expected format is
+            `{"type": strategy name, "factor": scaling factor}`. When using this flag, don't update
+            `max_position_embeddings` to the expected new maximum. See the following thread for more information on how
+            these scaling strategies behave:
+            https://www.reddit.com/r/LocalLLaMA/comments/14mrgpr/dynamically_scaled_rope_further_increases/. This is an
+            experimental feature, subject to breaking API changes in future versions.
+        classifier_dropout (`float`, *optional*):
+            The dropout ratio for the classification head.
+
+    Examples:
+
+    ```python
+    >>> from transformers import NewConfig, NewModel
+
+    >>> # Initializing a NEW izhx/new-base-en style configuration
+    >>> configuration = NewConfig()
+
+    >>> # Initializing a model (with random weights) from the izhx/new-base-en style configuration
+    >>> model = NewModel(configuration)
+
+    >>> # Accessing the model configuration
+    >>> configuration = model.config
+    ```"""
+
+    model_type = "new"
+
+    def __init__(
+        self,
+        vocab_size=30528,
+        hidden_size=768,
+        num_hidden_layers=12,
+        num_attention_heads=12,
+        intermediate_size=3072,
+        hidden_act="gelu",
+        hidden_dropout_prob=0.1,
+        attention_probs_dropout_prob=0.0,
+        max_position_embeddings=2048,
+        type_vocab_size=1,
+        initializer_range=0.02,
+        layer_norm_type='layer_norm',
+        layer_norm_eps=1e-12,
+        # pad_token_id=0,
+        position_embedding_type="rope",
+        rope_theta=10000.0,
+        rope_scaling=None,
+        classifier_dropout=None,
+        pack_qkv=True,
+        unpad_inputs=False,
+        use_memory_efficient_attention=False,
+        logn_attention_scale=False,
+        logn_attention_clip1=False,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+
+        self.vocab_size = vocab_size
+        self.hidden_size = hidden_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.hidden_act = hidden_act
+        self.intermediate_size = intermediate_size
+        self.hidden_dropout_prob = hidden_dropout_prob
+        self.attention_probs_dropout_prob = attention_probs_dropout_prob
+        self.max_position_embeddings = max_position_embeddings
+        self.type_vocab_size = type_vocab_size
+        self.initializer_range = initializer_range
+        self.layer_norm_type = layer_norm_type
+        self.layer_norm_eps = layer_norm_eps
+        self.position_embedding_type = position_embedding_type
+        self.rope_theta = rope_theta
+        self.rope_scaling = rope_scaling
+        self.classifier_dropout = classifier_dropout
+
+        self.pack_qkv = pack_qkv
+        self.unpad_inputs = unpad_inputs
+        self.use_memory_efficient_attention = use_memory_efficient_attention
+        self.logn_attention_scale = logn_attention_scale
+        self.logn_attention_clip1 = logn_attention_clip1

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aaecab17eb05daa8280ee92d78079f248305f3e3cecb6294a0ae5d448bb96259
+size 1221487872

modeling.py

@@ -0,0 +1,1418 @@
+# coding=utf-8
+# Copyright 2024 The GTE Team Authors and Alibaba Group.
+# Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""PyTorch NEW model."""
+
+import math
+from dataclasses import dataclass
+from typing import List, Optional, Tuple, Union
+
+import torch
+import torch.utils.checkpoint
+from torch import nn
+
+from transformers.activations import ACT2FN
+from transformers.modeling_outputs import (
+    BaseModelOutput,
+    BaseModelOutputWithPooling,
+    MaskedLMOutput,
+    MultipleChoiceModelOutput,
+    QuestionAnsweringModelOutput,
+    SequenceClassifierOutput,
+    ModelOutput,
+)
+from transformers.modeling_utils import PreTrainedModel
+from transformers.utils import logging
+
+try:
+    import xformers.ops as xops
+except ImportError as e:
+    xops = None
+
+from .configuration import NewConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+# Adapted from https://github.com/HazyResearch/flash-attention/blob/main/flash_attn/bert_padding.py
+# Which was adapted from https://github.com/mlcommons/training_results_v1.1/blob/main/NVIDIA/benchmarks/bert/implementations/pytorch/padding.py
+class IndexFirstAxis(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, input, indices):
+        ctx.save_for_backward(indices)
+        assert input.ndim >= 2
+        ctx.first_axis_dim, other_shape = input.shape[0], input.shape[1:]
+        second_dim = other_shape.numel()
+        # TD [2022-03-04] For some reason torch.gather is a bit faster than indexing.
+        # return input[indices]
+        # return torch.gather(
+        #     rearrange(input, "b ... -> b (...)"), 0, repeat(indices, "z -> z d", d=second_dim)
+        # ).reshape(-1, *other_shape)
+        return torch.gather(
+            input.view(ctx.first_axis_dim, second_dim),
+            0,
+            indices.unsqueeze(-1).expand(indices.size(0), second_dim)
+        ).reshape(-1, *other_shape)
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        (indices,) = ctx.saved_tensors
+        assert grad_output.ndim >= 2
+        other_shape = grad_output.shape[1:]
+        # grad_output = rearrange(grad_output, "b ... -> b (...)")
+        grad_output = grad_output.view(grad_output.size(0), other_shape.numel())
+        grad_input = torch.zeros(
+            [ctx.first_axis_dim, grad_output.shape[1]],
+            device=grad_output.device,
+            dtype=grad_output.dtype,
+        )
+        # TD [2022-03-04] For some reason torch.scatter is a bit faster than indexing.
+        # grad_input[indices] = grad_output
+        # grad_input.scatter_(0, repeat(indices, "z -> z d", d=grad_output.shape[1]), grad_output)
+        grad_input.scatter_(
+            0, indices.unsqueeze(-1).expand(indices.size(0), grad_output.size(1)), grad_output
+        )
+        return grad_input.reshape(ctx.first_axis_dim, *other_shape), None
+
+
+index_first_axis = IndexFirstAxis.apply
+
+
+def unpad_input(hidden_states, attention_mask=None, indices=None):
+    """
+    Arguments:
+        hidden_states: (batch, seqlen, ...)
+        attention_mask: (batch, seqlen), bool / int, 1 means valid and 0 means not valid.
+        indices: (total_nnz), the indices of non-masked tokens from the flattened input sequence.
+    Return:
+        hidden_states: (total_nnz, ...), where total_nnz = number of tokens in selected in attention_mask.
+    """
+    if indices is None:
+        assert attention_mask is not None
+        indices = torch.nonzero(attention_mask.flatten(), as_tuple=False).flatten()
+
+    # TD [2022-03-04] We don't want to index with a bool mask, because Pytorch will expand the
+    # bool mask, then call nonzero to get the indices, then index with those. The indices is @dim
+    # times larger than it needs to be, wasting memory. It's faster and more memory-efficient to
+    # index with integer indices. Moreover, torch's index is a bit slower than it needs to be,
+    # so we write custom forward and backward to make it a bit faster.
+    hidden_states = hidden_states.view(-1, *hidden_states.shape[2:])
+    return index_first_axis(hidden_states, indices)
+
+
+class IndexPutFirstAxis(torch.autograd.Function):
+    @staticmethod
+    def forward(
+        ctx,
+        values: torch.Tensor,
+        indices: torch.Tensor,
+        first_axis_dim
+    ) -> torch.Tensor:
+        ctx.save_for_backward(indices)
+        assert indices.ndim == 1
+        assert values.ndim >= 2
+        output = torch.zeros(
+            first_axis_dim, *values.shape[1:], device=values.device, dtype=values.dtype
+        )
+        output[indices] = values
+        return output
+
+    @staticmethod
+    def backward(ctx, grad_output: torch.Tensor) -> Tuple[torch.Tensor, None, None]:
+        indices, = ctx.saved_tensors
+        grad_values = grad_output[indices]
+        return grad_values, None, None
+
+
+index_put_first_axis = IndexPutFirstAxis.apply
+
+
+def pad_input(inputs: torch.Tensor, indices: torch.Tensor, batch: int, seqlen: int) -> torch.Tensor:
+    """Add padding to sequences.
+
+    Arguments:
+        inputs: (total_nnz, ...), where total_nnz = number of tokens in selected in attention_mask.
+        indices: (total_nnz), `indices = torch.nonzero(attention_mask.flatten(), as_tuple=False).flatten()`
+        batch: int batch_size
+        seqlen: int max sequence length
+
+    Returns:
+        inputs: (batch, seqlen, ...)
+    """
+    output = index_put_first_axis(inputs, indices, batch * seqlen)
+    return output.view(batch, seqlen, *inputs.shape[1:])
+
+
+def rotate_half(x):
+    """Rotates half the hidden dims of the input."""
+    x1 = x[..., : x.shape[-1] // 2]
+    x2 = x[..., x.shape[-1] // 2 :]
+    return torch.cat((-x2, x1), dim=-1)
+
+
+def apply_rotary_pos_emb(q, k, cos, sin):
+    """Applies Rotary Position Embedding to the query and key tensors.
+
+    Args:
+        q (`torch.Tensor`): The query tensor.
+        k (`torch.Tensor`): The key tensor.
+        cos (`torch.Tensor`): The cosine part of the rotary embedding.
+        sin (`torch.Tensor`): The sine part of the rotary embedding.
+    Returns:
+        `tuple(torch.Tensor)` comprising of the query and key tensors rotated using the Rotary Position Embedding.
+    """
+    cos, sin = cos.to(q.dtype), sin.to(q.dtype)
+    q_embed = (q * cos) + (rotate_half(q) * sin)
+    k_embed = (k * cos) + (rotate_half(k) * sin)
+    return q_embed, k_embed
+
+
+class RotaryEmbedding(torch.nn.Module):
+    def __init__(self, dim, max_position_embeddings=512, base=10000.0, device=None):
+        super().__init__()
+
+        self.dim = dim
+        self.max_position_embeddings = max_position_embeddings
+        self.base = base
+        inv_freq = 1.0 / (self.base ** (torch.arange(0, self.dim, 2).float().to(device) / self.dim))
+        self.register_buffer("inv_freq", inv_freq, persistent=False)
+
+        # Build here to make `torch.jit.trace` work.
+        self._set_cos_sin_cache(
+            seq_len=max_position_embeddings, device=self.inv_freq.device, dtype=torch.get_default_dtype()
+        )
+
+    def _set_cos_sin_cache(self, seq_len, device, dtype):
+        self.max_seq_len_cached = seq_len
+        t = torch.arange(self.max_seq_len_cached, device=device, dtype=torch.float32)
+
+        freqs = torch.einsum("i,j->ij", t, self.inv_freq)
+        # Different from paper, but it uses a different permutation in order to obtain the same calculation
+        emb = torch.cat((freqs, freqs), dim=-1)
+        self.register_buffer("cos_cached", emb.cos().to(dtype), persistent=False)
+        self.register_buffer("sin_cached", emb.sin().to(dtype), persistent=False)
+
+    def forward(self, x, seq_len=None):
+        # x: [bs, num_attention_heads, seq_len, head_size]
+        if seq_len > self.max_seq_len_cached:
+            self._set_cos_sin_cache(seq_len=seq_len, device=x.device, dtype=x.dtype)
+
+        return (
+            self.cos_cached[:seq_len, ...].to(dtype=x.dtype),
+            self.sin_cached[:seq_len, ...].to(dtype=x.dtype),
+        )
+
+
+class NTKScalingRotaryEmbedding(RotaryEmbedding):
+    """RotaryEmbedding extended with fixed and mixed NTK scaling. https://kexue.fm/archives/9706 """
+
+    def __init__(self, dim, max_position_embeddings=512, base=10000, device=None, scaling_factor=1.0, mixed_b=None):
+        self.scaling_factor = scaling_factor
+        self.mixed_b = mixed_b
+        super().__init__(dim, max_position_embeddings, base, device)
+        max_position_embeddings = max_position_embeddings * self.scaling_factor
+        self._set_cos_sin_cache(max_position_embeddings, self.inv_freq.device, torch.get_default_dtype())
+
+    def _set_cos_sin_cache(self, seq_len, device, dtype):
+        self.max_seq_len_cached = seq_len
+
+        if seq_len > self.max_position_embeddings:
+            base = self.base * (self.scaling_factor if self.mixed_b is None else 1)
+            inv_freq = 1.0 / (base ** (torch.arange(0, self.dim, 2).float().to(device) / self.dim))
+
+            if self.mixed_b is None:
+                inv_freq = inv_freq / self.scaling_factor ** (2 / self.dim)  # (6)
+            else:
+                a = torch.tensor(self.scaling_factor).log() / (self.dim / 2) ** self.mixed_b  # (13)
+                lambda_1_m = (a * torch.arange(1, self.dim // 2 + 1).float().to(device) ** self.mixed_b).exp()  # (12)
+                inv_freq = inv_freq / lambda_1_m  # (10)
+
+            self.register_buffer("inv_freq", inv_freq, persistent=False)
+
+        t = torch.arange(self.max_seq_len_cached, device=device, dtype=torch.float32)
+
+        freqs = torch.einsum("i,j->ij", t, self.inv_freq)
+        # Different from paper, but it uses a different permutation in order to obtain the same calculation
+        emb = torch.cat((freqs, freqs), dim=-1)
+        self.register_buffer("cos_cached", emb.cos().to(dtype), persistent=False)
+        self.register_buffer("sin_cached", emb.sin().to(dtype), persistent=False)
+
+
+class RMSNorm(nn.Module):
+    def __init__(self, hidden_size, eps=1e-6):
+        """
+        RMSNorm is equivalent to T5LayerNorm
+        """
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(hidden_size))
+        self.variance_epsilon = eps
+
+    def forward(self, hidden_states):
+        input_dtype = hidden_states.dtype
+        hidden_states = hidden_states.to(torch.float32)
+        variance = hidden_states.pow(2).mean(-1, keepdim=True)
+        hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
+        return self.weight * hidden_states.to(input_dtype)
+
+
+LAYER_NORM = {
+    'layer_norm': nn.LayerNorm,
+    'rms_norm': RMSNorm
+}
+
+
+class NewEmbeddings(nn.Module):
+    """
+    Embedding and Unpadding.
+    """
+
+    def __init__(self, config: NewConfig):
+        super().__init__()
+        self.padding_idx = config.pad_token_id
+        self.word_embeddings = nn.Embedding(
+            config.vocab_size, config.hidden_size, padding_idx=self.padding_idx
+        )
+
+        self.position_embedding_type = config.position_embedding_type
+        if self.position_embedding_type == 'absolute':
+            self.position_embeddings = nn.Embedding(
+                config.max_position_embeddings, config.hidden_size, padding_idx=self.padding_idx
+            )
+        elif self.position_embedding_type == 'rope':
+            self._init_rope(config)
+        else:
+            raise ValueError
+
+        self.type_vocab_size = config.type_vocab_size
+        if self.type_vocab_size > 0:
+            self.token_type_embeddings = nn.Embedding(config.type_vocab_size, config.hidden_size)
+
+        # self.LayerNorm is not snake-cased to stick with TensorFlow model variable name and be able to load
+        # any TensorFlow checkpoint file
+        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+        # position_ids is contiguous in memory and excluded when serialized
+        self.register_buffer(
+            "position_ids", torch.arange(config.max_position_embeddings), persistent=False
+        )
+
+    def _init_rope(self, config):
+        kwargs = dict(
+            dim=int(config.hidden_size / config.num_attention_heads),
+            max_position_embeddings=config.max_position_embeddings,
+            base=config.rope_theta
+        )
+        if config.rope_scaling is None:
+            self.rotary_emb = RotaryEmbedding(**kwargs)
+        else:
+            kwargs.update(scaling_factor=config.rope_scaling["factor"])
+            scaling_type = config.rope_scaling["type"]
+            if scaling_type == 'ntk':
+                kwargs.update(mixed_b=config.rope_scaling.get('mixed_b', None))
+                self.rotary_emb = NTKScalingRotaryEmbedding(**kwargs)
+            # elif scaling_type == "linear":
+            #     self.rotary_emb = LinearScalingRotaryEmbedding(**kwargs)
+            # elif scaling_type == "dynamic":
+            #     self.rotary_emb = DynamicNTKScalingRotaryEmbedding(**kwargs)
+            else:
+                raise ValueError(f"Unknown RoPE scaling type {scaling_type}")
+
+    def forward(
+        self,
+        unpad_inputs: bool,
+        input_ids: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        length: Optional[List[int]] = None,
+        token_type_ids: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.Tensor] = None,
+        inputs_embeds: Optional[torch.Tensor] = None,
+    ) -> Tuple[torch.Tensor, torch.Tensor, Optional[Tuple], Optional[List[int]]]:
+        """
+        """
+        if inputs_embeds is None:
+            device, input_shape = input_ids.device, input_ids.shape
+        else:
+            device, input_shape = inputs_embeds.device, inputs_embeds.shape[:2]
+        batch_size, seq_length = input_shape
+
+        # Set attention_mask if it's None
+        if attention_mask is None:
+            attention_mask = torch.ones(input_shape, device=device)
+            if length is not None:
+                for i, l in enumerate(length):
+                    attention_mask[i, l:] = 0
+
+        # Set attention_mask_bool for unpadding
+        if unpad_inputs:
+            attention_mask_bool = attention_mask.bool()
+            if length is None:
+                length = attention_mask.sum(-1).tolist()
+
+        # Get word embeddings
+        if inputs_embeds is None:
+            if unpad_inputs:
+                input_ids = input_ids[attention_mask_bool].unsqueeze(0)
+            inputs_embeds = self.word_embeddings(input_ids)
+        else:
+            if unpad_inputs:
+                inputs_embeds = inputs_embeds[attention_mask_bool].unsqueeze(0)
+        embeddings = inputs_embeds
+
+        # Set and unpad position_ids
+        if position_ids is None:
+            if seq_length > self.position_ids.size(0):
+                self.register_buffer(
+                    "position_ids", torch.arange(seq_length, device=embeddings.device), persistent=False
+                )
+            if unpad_inputs:
+                # [1, cumsum_seq_len]
+                position_ids = torch.cat([self.position_ids[:l] for l in length]).unsqueeze(0)
+            else:
+                # [bs, seq_len]
+                position_ids = self.position_ids[:seq_length].expand(batch_size, -1)
+        elif unpad_inputs:
+            position_ids = position_ids[attention_mask_bool].unsqueeze(0)  # [1, cumsum_seq_len]
+
+        # Compute rotary embedding
+        if self.position_embedding_type == 'rope':
+            rope_cos, rope_sin = self.rotary_emb(inputs_embeds, seq_len=seq_length)
+            rope_cos = rope_cos[position_ids].unsqueeze(2)  # [bs, seq_len, 1, dim]
+            rope_sin = rope_sin[position_ids].unsqueeze(2)  # [bs, seq_len, 1, dim]
+            rope_embeds = rope_cos, rope_sin
+        else:
+            rope_embeds = None
+
+        if self.type_vocab_size > 0:
+            if token_type_ids is None:
+                token_type_ids = position_ids.mul(0)
+            else:
+                if self.type_vocab_size < 2:
+                    token_type_ids.mul_(0)
+                if unpad_inputs:
+                    token_type_ids = token_type_ids[attention_mask_bool].unsqueeze(0)
+
+            token_type_embeddings = self.token_type_embeddings(token_type_ids)
+            embeddings = embeddings + token_type_embeddings
+
+        # BERT position
+        if self.position_embedding_type == "absolute":
+            position_embeddings = self.position_embeddings(position_ids)
+            embeddings = embeddings + position_embeddings
+
+        embeddings = self.LayerNorm(embeddings)
+        embeddings = self.dropout(embeddings)
+
+        return embeddings, attention_mask, rope_embeds, length
+
+
+class NewAttention(nn.Module):
+    def __init__(self, config: NewConfig, pack_qkv=None, use_memory_efficient_attention=None):
+        super().__init__()
+        self.config = config
+        if config.hidden_size % config.num_attention_heads != 0 and not hasattr(config, "embedding_size"):
+            raise ValueError(
+                f"The hidden size ({config.hidden_size}) is not a multiple of the number of attention "
+                f"heads ({config.num_attention_heads})"
+            )
+
+        self.hidden_size = config.hidden_size
+        self.num_attention_heads = config.num_attention_heads
+        self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
+        self.all_head_size = self.num_attention_heads * self.attention_head_size
+
+        if pack_qkv is None:
+            pack_qkv = config.pack_qkv
+        self.pack_qkv = pack_qkv
+
+        if self.pack_qkv:
+            self.qkv_proj = nn.Linear(config.hidden_size, self.all_head_size * 3, bias=True)
+        else:
+            self.q_proj = nn.Linear(config.hidden_size, self.all_head_size, bias=True)
+            self.k_proj = nn.Linear(config.hidden_size, self.all_head_size, bias=True)
+            self.v_proj = nn.Linear(config.hidden_size, self.all_head_size, bias=True)
+
+        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+        self.o_proj = nn.Linear(config.hidden_size, config.hidden_size, bias=True)
+
+        if use_memory_efficient_attention is None:
+            use_memory_efficient_attention = self.config.use_memory_efficient_attention
+        self.use_memory_efficient_attention = use_memory_efficient_attention
+        self.memory_efficient_attention = None if xops is None else xops.memory_efficient_attention
+        if self.use_memory_efficient_attention:
+            assert self.memory_efficient_attention is not None, 'please install xformers'
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_bias: torch.FloatTensor,
+        rope_embeds: Optional[Tuple[torch.FloatTensor, torch.FloatTensor]] = None,
+        padding_inputs: Optional[Tuple] = None,  # indices, batch, seqlen
+        attention_scale: Optional[torch.FloatTensor] = None,
+        head_mask: Optional[torch.FloatTensor] = None,
+        output_attentions: Optional[bool] = False,
+        qkv_inputs: Optional[Tuple] = None,  # For RetroMAE
+    ) -> Tuple[torch.Tensor, ...]:
+        shape_hd = (self.num_attention_heads, self.attention_head_size)
+        # qkv
+        if self.pack_qkv and qkv_inputs is None:
+            qkv_pack = self.qkv_proj(hidden_states).split(self.all_head_size, dim=-1)
+        else:
+            if qkv_inputs is None:
+                qkv_inputs = (hidden_states, hidden_states, hidden_states)
+            qkv_pack = [
+                getattr(self, n + '_proj')(s) for s, n in zip(qkv_inputs, 'qkv')
+            ]
+        query_states, key_states, value_states = [t.view(t.shape[:-1] + shape_hd) for t in qkv_pack]
+
+        if self.config.position_embedding_type == 'rope':
+            query_states, key_states = apply_rotary_pos_emb(query_states, key_states, *rope_embeds)
+
+        dtype = query_states.dtype
+
+        if self.config.logn_attention_scale and attention_scale is not None:
+            # https://kexue.fm/archives/8823
+            query_states = query_states * attention_scale.to(dtype)
+
+        if padding_inputs is not None:
+            query_states = pad_input(query_states.squeeze(), *padding_inputs)
+            key_states = pad_input(key_states.squeeze(), *padding_inputs)
+            value_states = pad_input(value_states.squeeze(), *padding_inputs)
+
+        if self.use_memory_efficient_attention:
+            assert self.memory_efficient_attention is not None, "xformers is not loaded"
+            assert output_attentions is False, "memory_efficient_attention do not output attentions"
+            assert head_mask is None, "Not support yet"
+            attention_probs = None
+            if torch.is_tensor(attention_bias):
+                attention_bias = attention_bias.to(dtype)
+            context_layer = self.memory_efficient_attention(
+                query_states,
+                key_states,
+                value_states,
+                attn_bias=attention_bias,
+                p=self.dropout.p
+            )
+        else:
+            if output_attentions and isinstance(self, NewSdpaAttention):
+                raise RuntimeError("SDPA do not output attentions")
+            context_layer, attention_probs = self._attention(
+                query_states, key_states, value_states, attention_bias, head_mask
+            )
+
+        if padding_inputs is not None:
+            context_layer = unpad_input(context_layer, indices=padding_inputs[0])
+
+        new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
+        context_layer = context_layer.view(new_context_layer_shape)
+
+        # output proj
+        attn_output = self.o_proj(context_layer)
+
+        # add attentions if we output them
+        outputs = (attn_output, attention_probs) if output_attentions else (attn_output,)
+        return outputs
+
+    def _attention(self, query_states, key_states, value_states, attention_bias, head_mask):
+        """
+        Args:
+            q/k/v: (B, L, n_head, head_dim),
+        Returns:
+            attn_output: (B L, n_head, head_dim)
+        """
+        query_states = query_states.transpose(1, 2)
+        key_states = key_states.transpose(1, 2)
+        value_states = value_states.transpose(1, 2)
+        # Take the dot product between "query" and "key" to get the raw attention scores.
+        attention_scores = torch.matmul(query_states, key_states.transpose(-1, -2))
+
+        attention_scores = attention_scores / math.sqrt(self.attention_head_size)
+        if attention_bias is not None:
+            # Apply the attention mask is (precomputed for all layers in BertModel forward() function)
+            attention_scores = attention_scores + attention_bias
+
+        # Normalize the attention scores to probabilities.
+        attention_probs = nn.functional.softmax(attention_scores, dim=-1)
+
+        # This is actually dropping out entire tokens to attend to, which might
+        # seem a bit unusual, but is taken from the original Transformer paper.
+        if self.dropout.p > 0:
+            attention_probs = self.dropout(attention_probs)
+
+        # Mask heads if we want to
+        if head_mask is not None:
+            attention_probs = attention_probs * head_mask
+
+        context_layer = torch.matmul(attention_probs, value_states)
+
+        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
+        return context_layer, attention_probs
+
+
+class NewSdpaAttention(NewAttention):
+    """
+    New attention module using torch.nn.functional.scaled_dot_product_attention. This module inherits from
+    `NewAttention` as the weights of the module stays untouched. The only changes are on the forward pass to adapt to
+    SDPA API.
+    """
+    def __init__(self, config: NewConfig, **kwargs):
+        super().__init__(config, **kwargs)
+        # torch.backends.cuda.enable_mem_efficient_sdp(False)
+        # logger.warning(
+        #     "Disable memory efficient attention kernel for `NewSdpaAttention`, you can set "
+        #     "`use_memory_efficient_attention=True` if it expected to use."
+        # )
+
+    def _attention(self, query_states, key_states, value_states, attention_bias, head_mask):
+        attn_output = torch.nn.functional.scaled_dot_product_attention(
+            query_states.transpose(1, 2),
+            key_states.transpose(1, 2),
+            value_states.transpose(1, 2),
+            attn_mask=attention_bias,
+            dropout_p=self.dropout.p if self.training else 0.0,
+        )
+        attn_output = attn_output.permute(0, 2, 1, 3).contiguous()
+        return attn_output, None
+
+
+NEW_ATTENTION_CLASSES = {
+    "eager": NewAttention,
+    # "flash_attention_2": ,  # TODO
+    "sdpa": NewSdpaAttention,
+}
+
+
+class NewGatedMLP(nn.Module):
+    """
+    GLU Variants Improve Transformer.
+    """
+
+    def __init__(self, config: NewConfig):
+        super().__init__()
+        self.intermediate_size = config.intermediate_size
+        self.up_gate_proj = nn.Linear(config.hidden_size, self.intermediate_size * 2, bias=False)
+        self.down_proj = nn.Linear(self.intermediate_size, config.hidden_size, bias=True)
+        self.act_fn = ACT2FN[config.hidden_act]
+        if config.hidden_dropout_prob > 0:
+            self.hidden_dropout = nn.Dropout(config.hidden_dropout_prob)
+        else:
+            self.hidden_dropout = None
+
+    def forward(self, hidden_states):
+        up_gate = self.up_gate_proj(hidden_states)
+        up_states, gate = torch.split(up_gate, self.intermediate_size, dim=-1)
+        gate = self.act_fn(gate)
+        gated_states = gate * up_states
+        if self.hidden_dropout is not None:
+            gated_states = self.hidden_dropout(gated_states)
+        down_states = self.down_proj(gated_states)
+        return down_states
+
+
+class NewLayer(nn.Module):
+    def __init__(
+        self,
+        config: NewConfig,
+        pack_qkv=None,
+        use_memory_efficient_attention=None,
+        attn_implementation=None
+    ):
+        super().__init__()
+        if attn_implementation is None:
+            attn_implementation = config._attn_implementation
+        if use_memory_efficient_attention is None:
+            use_memory_efficient_attention = config.use_memory_efficient_attention
+        if use_memory_efficient_attention:
+            if attn_implementation != 'eager':
+                logger.warning_once(f"Override {attn_implementation=} to 'eager' as {use_memory_efficient_attention=}")
+                attn_implementation = 'eager'  # Since it will be SDPA by default for torch>=2.1.1
+        self.attention = NEW_ATTENTION_CLASSES[attn_implementation](
+            config, pack_qkv=pack_qkv, use_memory_efficient_attention=use_memory_efficient_attention
+        )
+        self.mlp = NewGatedMLP(config)
+
+        ln_class = LAYER_NORM[config.layer_norm_type]
+        self.attn_ln = ln_class(config.hidden_size, eps=config.layer_norm_eps)
+        self.mlp_ln = ln_class(config.hidden_size, eps=config.layer_norm_eps)
+
+        if config.hidden_dropout_prob > 0:
+            self.hidden_dropout = nn.Dropout(config.hidden_dropout_prob)
+        else:
+            self.hidden_dropout = None
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_bias: torch.FloatTensor,
+        rope_embeds: Optional[Tuple[torch.FloatTensor, torch.FloatTensor]] = None,
+        padding_inputs: Optional[Tuple] = None,  # indices, batch, seqlen
+        attention_scale: Optional[torch.FloatTensor] = None,
+        subset_indices: Optional[torch.LongTensor] = None,
+        head_mask: Optional[torch.FloatTensor] = None,
+        output_attentions: Optional[bool] = False,
+        qkv_inputs: Optional[Tuple] = None,  # For RetroMAE
+    ) -> Tuple[torch.Tensor, ...]:
+        # Multi head self attention
+        residual = hidden_states if qkv_inputs is None else qkv_inputs[0]
+        attention_outputs = self.attention(
+            hidden_states,
+            attention_bias,
+            rope_embeds,
+            padding_inputs,
+            attention_scale,
+            head_mask,
+            output_attentions=output_attentions,
+            qkv_inputs=qkv_inputs,
+        )
+        hidden_states = attention_outputs[0]
+        if self.hidden_dropout is not None:
+            hidden_states = self.hidden_dropout(hidden_states)
+        hidden_states = residual + hidden_states
+
+        # In pretraining, after the attention of last layer, we only need the masked tokens.
+        if subset_indices is not None:
+            hidden_states = hidden_states[subset_indices]
+
+        hidden_states = self.attn_ln(hidden_states)
+
+        # Fully Connected
+        residual = hidden_states
+        hidden_states = self.mlp(hidden_states)
+        if self.hidden_dropout is not None:
+            hidden_states = self.hidden_dropout(hidden_states)
+        hidden_states = residual + hidden_states
+        hidden_states = self.mlp_ln(hidden_states)
+
+        # add self attentions if we output attention weights
+        outputs = (hidden_states,) + attention_outputs[1:]
+        return outputs
+
+
+class NewEncoder(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.layer = nn.ModuleList([NewLayer(config) for _ in range(config.num_hidden_layers)])
+        self.gradient_checkpointing = False
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_bias: Optional[torch.FloatTensor] = None,
+        rope_embeds: Optional[Tuple[torch.FloatTensor, torch.FloatTensor]] = None,
+        padding_inputs: Optional[Tuple] = None,  # indices, batch, seqlen
+        attention_scale: Optional[torch.FloatTensor] = None,
+        subset_indices: Optional[torch.LongTensor] = None,
+        head_mask: Optional[torch.FloatTensor] = None,
+        output_attentions: Optional[bool] = False,
+        output_hidden_states: Optional[bool] = False,
+        return_dict: Optional[bool] = True,
+    ) -> Union[Tuple[torch.Tensor], BaseModelOutput]:
+        all_hidden_states = () if output_hidden_states else None
+        all_self_attentions = () if output_attentions else None
+
+        for i, layer_module in enumerate(self.layer):
+            if output_hidden_states:
+                all_hidden_states = all_hidden_states + (hidden_states,)
+
+            if i >= len(self.layer) - 1:
+                layer_subset_indices = subset_indices
+            else:
+                layer_subset_indices = None
+
+            layer_head_mask = head_mask[i] if head_mask is not None else None
+
+            if self.gradient_checkpointing and self.training:
+                layer_outputs = self._gradient_checkpointing_func(
+                    layer_module.__call__,
+                    hidden_states,
+                    attention_bias,
+                    rope_embeds,
+                    padding_inputs,
+                    attention_scale,
+                    layer_subset_indices,
+                    layer_head_mask,
+                )
+            else:
+                layer_outputs = layer_module(
+                    hidden_states,
+                    attention_bias,
+                    rope_embeds,
+                    padding_inputs,
+                    attention_scale,
+                    layer_subset_indices,
+                    layer_head_mask,
+                    output_attentions,
+                )
+
+            hidden_states = layer_outputs[0]
+            if output_attentions:
+                all_self_attentions = all_self_attentions + (layer_outputs[1],)
+
+        if output_hidden_states:
+            all_hidden_states = all_hidden_states + (hidden_states,)
+
+        if not return_dict:
+            return tuple(
+                v
+                for v in [
+                    hidden_states,
+                    all_hidden_states,
+                    all_self_attentions,
+                ]
+                if v is not None
+            )
+        return BaseModelOutput(
+            last_hidden_state=hidden_states,
+            hidden_states=all_hidden_states,
+            attentions=all_self_attentions,
+        )
+
+
+# Copied from transformers.models.bert.modeling_bert.BertPooler with Bert->New
+class NewPooler(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        self.activation = nn.Tanh()
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        # We "pool" the model by simply taking the hidden state corresponding
+        # to the first token.
+        first_token_tensor = hidden_states[:, 0]
+        pooled_output = self.dense(first_token_tensor)
+        pooled_output = self.activation(pooled_output)
+        return pooled_output
+
+
+class NewPreTrainedModel(PreTrainedModel):
+    """
+    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
+    models.
+    """
+
+    config_class = NewConfig
+    base_model_prefix = "new"
+    supports_gradient_checkpointing = True
+    _supports_sdpa = True
+
+    def _init_weights(self, module):
+        """Initialize the weights"""
+        if isinstance(module, nn.Linear):
+            # Slightly different from the TF version which uses truncated_normal for initialization
+            # cf https://github.com/pytorch/pytorch/pull/5617
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.bias is not None:
+                module.bias.data.zero_()
+        elif isinstance(module, nn.Embedding):
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.padding_idx is not None:
+                module.weight.data[module.padding_idx].zero_()
+        elif isinstance(module, nn.LayerNorm):
+            module.bias.data.zero_()
+            module.weight.data.fill_(1.0)
+
+
+class NewModel(NewPreTrainedModel):
+    """
+    The bare New Model transformer outputting raw hidden-states without any specific head on top.
+    """
+
+    def __init__(self, config: NewConfig, add_pooling_layer=False):
+        super().__init__(config)
+        self.config = config
+
+        self.embeddings = NewEmbeddings(config)
+        self.encoder = NewEncoder(config)
+
+        self.pooler = NewPooler(config) if add_pooling_layer else None
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_input_embeddings(self):
+        return self.embeddings.word_embeddings
+
+    def set_input_embeddings(self, value):
+        self.embeddings.word_embeddings = value
+
+    def forward(
+        self,
+        input_ids: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        length: Optional[List[int]] = None,
+        subset_indices: Optional[torch.LongTensor] = None,
+        token_type_ids: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.Tensor] = None,
+        head_mask: Optional[torch.Tensor] = None,
+        inputs_embeds: Optional[torch.Tensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        unpad_inputs: Optional[bool] = None,
+    ) -> Union[Tuple[torch.Tensor], BaseModelOutputWithPooling]:
+        r"""
+        length  (`list` of length `batch_size`, *optional*):
+            If is `None`, return padded `last_hidden_state`.
+        subset_indices  ():
+            pass
+        unpad_inputs  (`bool`, *optional*):
+            pass
+        """
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        unpad_inputs = unpad_inputs if unpad_inputs is not None else self.config.unpad_inputs
+        output_padded = length is None
+
+        if input_ids is not None and inputs_embeds is not None:
+            raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
+        elif input_ids is not None:
+            self.warn_if_padding_and_no_attention_mask(input_ids, attention_mask)
+            input_shape = input_ids.size()
+        elif inputs_embeds is not None:
+            input_shape = inputs_embeds.size()[:-1]
+        else:
+            raise ValueError("You have to specify either input_ids or inputs_embeds")
+
+        # TODO: not used
+        # # Prepare head mask if needed
+        # # 1.0 in head_mask indicate we keep the head
+        # # attention_probs has shape bsz x n_heads x N x N
+        # # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
+        # # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
+        # head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)
+
+        # Get embeddings, may unpad them
+        (embedding_output, attention_mask, rope_embeds, length) = self.embeddings(
+            unpad_inputs,
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            length=length,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+            inputs_embeds=inputs_embeds
+        )
+
+        batch_size, seq_length = input_shape
+        if unpad_inputs and self.config.use_memory_efficient_attention:
+            attention_bias = xops.fmha.attn_bias.BlockDiagonalMask.from_seqlens(length)
+        else:
+            # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
+            # ourselves in which case we just need to make it broadcastable to all heads.
+            attention_bias = self.get_extended_attention_mask(attention_mask, input_shape)
+            if self.config.use_memory_efficient_attention:
+                # Invalid shape for attention bias: torch.Size([48, 1, 1, 512]) (expected (48, 12, 512, 512))
+                attention_bias = attention_bias.expand(-1, self.config.num_attention_heads, seq_length, -1)
+
+        padding_inputs = None
+        if unpad_inputs and (output_padded or not self.config.use_memory_efficient_attention):
+            indices = torch.nonzero(attention_mask.flatten(), as_tuple=False).flatten()
+            if not self.config.use_memory_efficient_attention:
+                padding_inputs = (indices, *input_shape)
+
+        attention_scale = None
+        if self.config.logn_attention_scale:
+            logger.warning_once("TODO: logn_attention_scale")
+        #     # attention scale log_512(input_len)
+        #     attention_scale = attention_mask.sum(1).log() / torch.tensor(self.config.max_position_embeddings).log()
+        #     # inference-time logn scale need clip 1
+        #     if self.config.logn_attention_clip1:
+        #         attention_scale.clip_(1)
+        #     attention_scale = attention_scale[:, None, None, None]
+        # else:
+        #     attention_scale = None
+
+        encoder_outputs = self.encoder(
+            embedding_output,
+            attention_bias=attention_bias,
+            rope_embeds=rope_embeds,
+            padding_inputs=padding_inputs,
+            attention_scale=attention_scale,
+            subset_indices=subset_indices,
+            head_mask=head_mask,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+        sequence_output = encoder_outputs[0]
+        if unpad_inputs and output_padded:
+            sequence_output = pad_input(
+                sequence_output.squeeze(), indices, batch_size, seq_length
+            )
+
+        pooled_output = self.pooler(sequence_output) if self.pooler is not None else None
+
+        if not return_dict:
+            return (sequence_output, pooled_output) + encoder_outputs[1:]
+
+        return BaseModelOutputWithPooling(
+            last_hidden_state=sequence_output,
+            pooler_output=pooled_output,
+            hidden_states=encoder_outputs.hidden_states,
+            attentions=encoder_outputs.attentions,
+        )
+
+
+class NewLMPredictionHead(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        self.transform_act_fn = ACT2FN[config.hidden_act]
+        self.norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+        # The output weights are the same as the input embeddings, but there is
+        # an output-only bias for each token.
+        self.decoder = nn.Linear(config.hidden_size, config.vocab_size)
+
+    def forward(self, hidden_states):
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.transform_act_fn(hidden_states)
+        hidden_states = self.norm(hidden_states)
+        hidden_states = self.decoder(hidden_states)
+        return hidden_states
+
+
+class NewForMaskedLM(NewPreTrainedModel):
+    _tied_weights_keys = ["lm_head.decoder.bias", "lm_head.decoder.weight"]
+
+    def __init__(self, config: NewConfig):
+        super().__init__(config)
+        self.new = NewModel(config, add_pooling_layer=False)
+        self.lm_head = NewLMPredictionHead(config)
+        self.loss_fct = nn.CrossEntropyLoss()
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_output_embeddings(self):
+        return self.lm_head.decoder
+
+    def set_output_embeddings(self, new_embeddings):
+        self.lm_head.decoder = new_embeddings
+
+    def forward(
+        self,
+        input_ids: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        token_type_ids: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.Tensor] = None,
+        head_mask: Optional[torch.Tensor] = None,
+        inputs_embeds: Optional[torch.Tensor] = None,
+        labels: Optional[torch.Tensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        unpad_inputs: Optional[bool] = None,
+    ) -> Union[Tuple[torch.Tensor], MaskedLMOutput]:
+        r"""
+        labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+            Labels for computing the masked language modeling loss. Indices should be in `[-100, 0, ...,
+            config.vocab_size]` (see `input_ids` docstring) Tokens with indices set to `-100` are ignored (masked), the
+            loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`
+        """
+
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        if labels is None or not self.new.config.unpad_inputs:
+            length = None
+            subset_indices = None
+        else:
+            length = attention_mask.sum(-1).tolist()
+            labels = labels[attention_mask.bool()].unsqueeze(0)
+            subset_indices = labels > -100
+
+        outputs = self.new(
+            input_ids,
+            attention_mask=attention_mask,
+            length=length,
+            subset_indices=subset_indices,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            unpad_inputs=unpad_inputs,
+        )
+
+        sequence_output = outputs[0]
+        prediction_scores = self.lm_head(sequence_output)
+
+        masked_lm_loss = None
+        if labels is not None:
+            if subset_indices is None:
+                mask = attention_mask.bool()
+                prediction_scores = prediction_scores[mask]
+                labels = labels[mask]
+            else:
+                labels = labels[subset_indices]
+            masked_lm_loss = self.loss_fct(prediction_scores, labels)
+
+        if not return_dict:
+            output = (prediction_scores,) + outputs[2:]
+            return ((masked_lm_loss,) + output) if masked_lm_loss is not None else output
+
+        return MaskedLMOutput(
+            loss=masked_lm_loss,
+            logits=prediction_scores,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+
+
+class NewForSequenceClassification(NewPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+        self.num_labels = config.num_labels
+        self.config = config
+
+        self.new = NewModel(config, add_pooling_layer=True)
+        classifier_dropout = (
+            config.classifier_dropout if config.classifier_dropout is not None else config.hidden_dropout_prob
+        )
+        self.dropout = nn.Dropout(classifier_dropout)
+        self.classifier = nn.Linear(config.hidden_size, config.num_labels)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def forward(
+        self,
+        input_ids: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        token_type_ids: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.Tensor] = None,
+        head_mask: Optional[torch.Tensor] = None,
+        inputs_embeds: Optional[torch.Tensor] = None,
+        labels: Optional[torch.Tensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        unpad_inputs: Optional[bool] = None,
+    ) -> Union[Tuple[torch.Tensor], SequenceClassifierOutput]:
+        r"""
+        labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+            Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+            config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+            `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        outputs = self.new(
+            input_ids,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            unpad_inputs=unpad_inputs,
+        )
+
+        pooled_output = outputs[1]
+
+        pooled_output = self.dropout(pooled_output)
+        logits = self.classifier(pooled_output)
+
+        loss = None
+        if labels is not None:
+            if self.config.problem_type is None:
+                if self.num_labels == 1:
+                    self.config.problem_type = "regression"
+                elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
+                    self.config.problem_type = "single_label_classification"
+                else:
+                    self.config.problem_type = "multi_label_classification"
+
+            if self.config.problem_type == "regression":
+                loss_fct = nn.MSELoss()
+                if self.num_labels == 1:
+                    loss = loss_fct(logits.squeeze(), labels.squeeze())
+                else:
+                    loss = loss_fct(logits, labels)
+            elif self.config.problem_type == "single_label_classification":
+                loss_fct = nn.CrossEntropyLoss()
+                loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
+            elif self.config.problem_type == "multi_label_classification":
+                loss_fct = nn.BCEWithLogitsLoss()
+                loss = loss_fct(logits, labels)
+
+        if not return_dict:
+            output = (logits,) + outputs[2:]
+            return ((loss,) + output) if loss is not None else output
+
+        return SequenceClassifierOutput(
+            loss=loss,
+            logits=logits,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+
+
+class NewForMultipleChoice(NewPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+
+        self.new = NewModel(config, add_pooling_layer=True)
+        classifier_dropout = (
+            config.classifier_dropout if config.classifier_dropout is not None else config.hidden_dropout_prob
+        )
+        self.dropout = nn.Dropout(classifier_dropout)
+        self.classifier = nn.Linear(config.hidden_size, 1)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def forward(
+        self,
+        input_ids: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        token_type_ids: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.Tensor] = None,
+        head_mask: Optional[torch.Tensor] = None,
+        inputs_embeds: Optional[torch.Tensor] = None,
+        labels: Optional[torch.Tensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        unpad_inputs: Optional[bool] = None,
+    ) -> Union[Tuple[torch.Tensor], MultipleChoiceModelOutput]:
+        r"""
+        labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+            Labels for computing the multiple choice classification loss. Indices should be in `[0, ...,
+            num_choices-1]` where `num_choices` is the size of the second dimension of the input tensors. (See
+            `input_ids` above)
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        num_choices = input_ids.shape[1] if input_ids is not None else inputs_embeds.shape[1]
+
+        input_ids = input_ids.view(-1, input_ids.size(-1)) if input_ids is not None else None
+        attention_mask = attention_mask.view(-1, attention_mask.size(-1)) if attention_mask is not None else None
+        token_type_ids = token_type_ids.view(-1, token_type_ids.size(-1)) if token_type_ids is not None else None
+        position_ids = position_ids.view(-1, position_ids.size(-1)) if position_ids is not None else None
+        inputs_embeds = (
+            inputs_embeds.view(-1, inputs_embeds.size(-2), inputs_embeds.size(-1))
+            if inputs_embeds is not None
+            else None
+        )
+
+        outputs = self.new(
+            input_ids,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            unpad_inputs=unpad_inputs,
+        )
+
+        pooled_output = outputs[1]
+
+        pooled_output = self.dropout(pooled_output)
+        logits = self.classifier(pooled_output)
+        reshaped_logits = logits.view(-1, num_choices)
+
+        loss = None
+        if labels is not None:
+            loss_fct = nn.CrossEntropyLoss()
+            loss = loss_fct(reshaped_logits, labels)
+
+        if not return_dict:
+            output = (reshaped_logits,) + outputs[2:]
+            return ((loss,) + output) if loss is not None else output
+
+        return MultipleChoiceModelOutput(
+            loss=loss,
+            logits=reshaped_logits,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+
+
+@dataclass
+class NewTokenClassifierOutput(ModelOutput):
+    loss: Optional[torch.FloatTensor] = None
+    logits: torch.FloatTensor = None
+    last_hidden_state: torch.FloatTensor = None
+    hidden_states: Optional[Tuple[torch.FloatTensor, ...]] = None
+    attentions: Optional[Tuple[torch.FloatTensor, ...]] = None
+
+
+class NewForTokenClassification(NewPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+        self.num_labels = config.num_labels
+
+        self.new = NewModel(config, add_pooling_layer=False)
+        classifier_dropout = (
+            config.classifier_dropout if config.classifier_dropout is not None else config.hidden_dropout_prob
+        )
+        self.dropout = nn.Dropout(classifier_dropout)
+        self.classifier = nn.Linear(config.hidden_size, config.num_labels)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def forward(
+        self,
+        input_ids: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        token_type_ids: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.Tensor] = None,
+        head_mask: Optional[torch.Tensor] = None,
+        inputs_embeds: Optional[torch.Tensor] = None,
+        labels: Optional[torch.Tensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        unpad_inputs: Optional[bool] = None,
+    ) -> Union[Tuple[torch.Tensor], NewTokenClassifierOutput]:
+        r"""
+        labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+            Labels for computing the token classification loss. Indices should be in `[0, ..., config.num_labels - 1]`.
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        outputs = self.new(
+            input_ids,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            unpad_inputs=unpad_inputs,
+        )
+
+        sequence_output = outputs[0]
+
+        sequence_output = self.dropout(sequence_output)
+        logits = self.classifier(sequence_output)
+
+        loss = None
+        if labels is not None:
+            loss_fct = nn.CrossEntropyLoss()
+            loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
+
+        if not return_dict:
+            output = (logits,) + outputs[2:]
+            return ((loss,) + output) if loss is not None else output
+
+        return NewTokenClassifierOutput(
+            loss=loss,
+            logits=logits,
+            last_hidden_state=sequence_output,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+
+
+class NewForQuestionAnswering(NewPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+        self.num_labels = config.num_labels
+
+        self.new = NewModel(config, add_pooling_layer=False)
+        self.qa_outputs = nn.Linear(config.hidden_size, config.num_labels)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def forward(
+        self,
+        input_ids: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        token_type_ids: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.Tensor] = None,
+        head_mask: Optional[torch.Tensor] = None,
+        inputs_embeds: Optional[torch.Tensor] = None,
+        start_positions: Optional[torch.Tensor] = None,
+        end_positions: Optional[torch.Tensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        unpad_inputs: Optional[bool] = None,
+    ) -> Union[Tuple[torch.Tensor], QuestionAnsweringModelOutput]:
+        r"""
+        start_positions (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+            Labels for position (index) of the start of the labelled span for computing the token classification loss.
+            Positions are clamped to the length of the sequence (`sequence_length`). Position outside of the sequence
+            are not taken into account for computing the loss.
+        end_positions (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+            Labels for position (index) of the end of the labelled span for computing the token classification loss.
+            Positions are clamped to the length of the sequence (`sequence_length`). Position outside of the sequence
+            are not taken into account for computing the loss.
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        outputs = self.new(
+            input_ids,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            unpad_inputs=unpad_inputs,
+        )
+
+        sequence_output = outputs[0]
+
+        logits = self.qa_outputs(sequence_output)
+        start_logits, end_logits = logits.split(1, dim=-1)
+        start_logits = start_logits.squeeze(-1).contiguous()
+        end_logits = end_logits.squeeze(-1).contiguous()
+
+        total_loss = None
+        if start_positions is not None and end_positions is not None:
+            # If we are on multi-GPU, split add a dimension
+            if len(start_positions.size()) > 1:
+                start_positions = start_positions.squeeze(-1)
+            if len(end_positions.size()) > 1:
+                end_positions = end_positions.squeeze(-1)
+            # sometimes the start/end positions are outside our model inputs, we ignore these terms
+            ignored_index = start_logits.size(1)
+            start_positions = start_positions.clamp(0, ignored_index)
+            end_positions = end_positions.clamp(0, ignored_index)
+
+            loss_fct = nn.CrossEntropyLoss(ignore_index=ignored_index)
+            start_loss = loss_fct(start_logits, start_positions)
+            end_loss = loss_fct(end_logits, end_positions)
+            total_loss = (start_loss + end_loss) / 2
+
+        if not return_dict:
+            output = (start_logits, end_logits) + outputs[2:]
+            return ((total_loss,) + output) if total_loss is not None else output
+
+        return QuestionAnsweringModelOutput(
+            loss=total_loss,
+            start_logits=start_logits,
+            end_logits=end_logits,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )

modules.json

@@ -0,0 +1,20 @@
+[
+  {
+    "idx": 0,
+    "name": "0",
+    "path": "",
+    "type": "sentence_transformers.models.Transformer"
+  },
+  {
+    "idx": 1,
+    "name": "1",
+    "path": "1_Pooling",
+    "type": "sentence_transformers.models.Pooling"
+  },
+  {
+    "idx": 2,
+    "name": "2",
+    "path": "2_Normalize",
+    "type": "sentence_transformers.models.Normalize"
+  }
+]

optimizer.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0541b9cb71a5d9764cf6fab34654aef49224a8d7a1bd4a5d87a1abc56904880e
+size 1767119051

rng_state.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5952bcab66003f5f91dd100986a0b8444b9c106dcb178659cc5a2360b9b998ce
+size 14645

scheduler.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0a8739adb42f0abfbbb7e4c25cf5e09cf981e44b780e76bdf7685bcb38f83592
+size 1465

sentence_bert_config.json

@@ -0,0 +1,4 @@
+{
+    "max_seq_length": 8192,
+    "do_lower_case": false
+}

special_tokens_map.json

@@ -0,0 +1,51 @@
+{
+  "bos_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "cls_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "mask_token": {
+    "content": "<mask>",
+    "lstrip": true,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<pad>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "sep_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aa7a6ad87a7ce8fe196787355f6af7d03aee94d19c54a5eb1392ed18c8ef451a
+size 17082988

tokenizer_config.json

@@ -0,0 +1,55 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "<s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "<pad>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "</s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "<unk>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "250001": {
+      "content": "<mask>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "bos_token": "<s>",
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "<s>",
+  "eos_token": "</s>",
+  "extra_special_tokens": {},
+  "mask_token": "<mask>",
+  "model_max_length": 8192,
+  "pad_token": "<pad>",
+  "sep_token": "</s>",
+  "tokenizer_class": "XLMRobertaTokenizerFast",
+  "unk_token": "<unk>"
+}

trainer_state.json

@@ -0,0 +1,327 @@
+{
+  "best_global_step": null,
+  "best_metric": null,
+  "best_model_checkpoint": null,
+  "epoch": 1.0,
+  "eval_steps": 79,
+  "global_step": 782,
+  "is_hyper_param_search": false,
+  "is_local_process_zero": true,
+  "is_world_process_zero": true,
+  "log_history": [
+    {
+      "epoch": 0,
+      "eval_cosine_accuracy@1": 0.232,
+      "eval_cosine_accuracy@10": 0.456,
+      "eval_cosine_accuracy@3": 0.3365,
+      "eval_cosine_accuracy@5": 0.389,
+      "eval_cosine_map@100": 0.14334533833340427,
+      "eval_cosine_mrr@10": 0.2988200396825396,
+      "eval_cosine_ndcg@10": 0.19590710853524823,
+      "eval_cosine_precision@1": 0.232,
+      "eval_cosine_precision@10": 0.10355000000000002,
+      "eval_cosine_precision@3": 0.177,
+      "eval_cosine_precision@5": 0.1452,
+      "eval_cosine_recall@1": 0.0548117388039026,
+      "eval_cosine_recall@10": 0.18984275866485092,
+      "eval_cosine_recall@3": 0.11065666057433865,
+      "eval_cosine_recall@5": 0.1464970398055657,
+      "eval_loss": 2.950530767440796,
+      "eval_runtime": 28.7759,
+      "eval_samples_per_second": 69.502,
+      "eval_steps_per_second": 1.112,
+      "step": 0
+    },
+    {
+      "epoch": 0.10112,
+      "grad_norm": 4.060101509094238,
+      "learning_rate": 4.936708860759494e-05,
+      "loss": 1.7256,
+      "step": 79
+    },
+    {
+      "epoch": 0.10112,
+      "eval_cosine_accuracy@1": 0.4915,
+      "eval_cosine_accuracy@10": 0.709,
+      "eval_cosine_accuracy@3": 0.6055,
+      "eval_cosine_accuracy@5": 0.65,
+      "eval_cosine_map@100": 0.37501954096960194,
+      "eval_cosine_mrr@10": 0.5594632936507937,
+      "eval_cosine_ndcg@10": 0.4471963096331387,
+      "eval_cosine_precision@1": 0.4915,
+      "eval_cosine_precision@10": 0.20455,
+      "eval_cosine_precision@3": 0.3835,
+      "eval_cosine_precision@5": 0.30490000000000006,
+      "eval_cosine_recall@1": 0.15563947633799366,
+      "eval_cosine_recall@10": 0.4411529898745371,
+      "eval_cosine_recall@3": 0.30525816129147315,
+      "eval_cosine_recall@5": 0.3661646057217302,
+      "eval_loss": 0.869914174079895,
+      "eval_runtime": 32.9054,
+      "eval_samples_per_second": 60.78,
+      "eval_steps_per_second": 0.972,
+      "step": 79
+    },
+    {
+      "epoch": 0.20224,
+      "grad_norm": 3.455092668533325,
+      "learning_rate": 4.4452347083926033e-05,
+      "loss": 0.8044,
+      "step": 158
+    },
+    {
+      "epoch": 0.20224,
+      "eval_cosine_accuracy@1": 0.538,
+      "eval_cosine_accuracy@10": 0.7835,
+      "eval_cosine_accuracy@3": 0.671,
+      "eval_cosine_accuracy@5": 0.72,
+      "eval_cosine_map@100": 0.4288531840469143,
+      "eval_cosine_mrr@10": 0.6170097222222221,
+      "eval_cosine_ndcg@10": 0.5071737492167014,
+      "eval_cosine_precision@1": 0.538,
+      "eval_cosine_precision@10": 0.22805,
+      "eval_cosine_precision@3": 0.419,
+      "eval_cosine_precision@5": 0.336,
+      "eval_cosine_recall@1": 0.18509011905489597,
+      "eval_cosine_recall@10": 0.5088450856238615,
+      "eval_cosine_recall@3": 0.35023499358379173,
+      "eval_cosine_recall@5": 0.42149330607177377,
+      "eval_loss": 0.6144608855247498,
+      "eval_runtime": 33.0639,
+      "eval_samples_per_second": 60.489,
+      "eval_steps_per_second": 0.968,
+      "step": 158
+    },
+    {
+      "epoch": 0.30336,
+      "grad_norm": 3.299586534500122,
+      "learning_rate": 3.883357041251778e-05,
+      "loss": 0.6254,
+      "step": 237
+    },
+    {
+      "epoch": 0.30336,
+      "eval_cosine_accuracy@1": 0.571,
+      "eval_cosine_accuracy@10": 0.807,
+      "eval_cosine_accuracy@3": 0.697,
+      "eval_cosine_accuracy@5": 0.747,
+      "eval_cosine_map@100": 0.45768471305297626,
+      "eval_cosine_mrr@10": 0.6465369047619048,
+      "eval_cosine_ndcg@10": 0.5352649581411899,
+      "eval_cosine_precision@1": 0.571,
+      "eval_cosine_precision@10": 0.23940000000000003,
+      "eval_cosine_precision@3": 0.446,
+      "eval_cosine_precision@5": 0.3534000000000001,
+      "eval_cosine_recall@1": 0.19728028074863738,
+      "eval_cosine_recall@10": 0.5336122046159524,
+      "eval_cosine_recall@3": 0.3745295533176793,
+      "eval_cosine_recall@5": 0.44429268806860206,
+      "eval_loss": 0.5068339705467224,
+      "eval_runtime": 32.9503,
+      "eval_samples_per_second": 60.697,
+      "eval_steps_per_second": 0.971,
+      "step": 237
+    },
+    {
+      "epoch": 0.40448,
+      "grad_norm": 2.563180685043335,
+      "learning_rate": 3.321479374110953e-05,
+      "loss": 0.5215,
+      "step": 316
+    },
+    {
+      "epoch": 0.40448,
+      "eval_cosine_accuracy@1": 0.6075,
+      "eval_cosine_accuracy@10": 0.855,
+      "eval_cosine_accuracy@3": 0.7495,
+      "eval_cosine_accuracy@5": 0.8005,
+      "eval_cosine_map@100": 0.4886299583708059,
+      "eval_cosine_mrr@10": 0.6879220238095239,
+      "eval_cosine_ndcg@10": 0.5725427973832125,
+      "eval_cosine_precision@1": 0.6075,
+      "eval_cosine_precision@10": 0.25585,
+      "eval_cosine_precision@3": 0.4696666666666666,
+      "eval_cosine_precision@5": 0.3763000000000001,
+      "eval_cosine_recall@1": 0.21129895871002893,
+      "eval_cosine_recall@10": 0.5768064108469603,
+      "eval_cosine_recall@3": 0.3986053442055735,
+      "eval_cosine_recall@5": 0.4793458893809688,
+      "eval_loss": 0.4230406582355499,
+      "eval_runtime": 32.9072,
+      "eval_samples_per_second": 60.777,
+      "eval_steps_per_second": 0.972,
+      "step": 316
+    },
+    {
+      "epoch": 0.5056,
+      "grad_norm": 2.914031744003296,
+      "learning_rate": 2.759601706970128e-05,
+      "loss": 0.4507,
+      "step": 395
+    },
+    {
+      "epoch": 0.5056,
+      "eval_cosine_accuracy@1": 0.6285,
+      "eval_cosine_accuracy@10": 0.8675,
+      "eval_cosine_accuracy@3": 0.753,
+      "eval_cosine_accuracy@5": 0.812,
+      "eval_cosine_map@100": 0.5064669285677783,
+      "eval_cosine_mrr@10": 0.7049886904761903,
+      "eval_cosine_ndcg@10": 0.5906093986384608,
+      "eval_cosine_precision@1": 0.6285,
+      "eval_cosine_precision@10": 0.26185,
+      "eval_cosine_precision@3": 0.4774999999999999,
+      "eval_cosine_precision@5": 0.38320000000000004,
+      "eval_cosine_recall@1": 0.22386914380224288,
+      "eval_cosine_recall@10": 0.5924252077258059,
+      "eval_cosine_recall@3": 0.4076045673568921,
+      "eval_cosine_recall@5": 0.4945358123439019,
+      "eval_loss": 0.3786991834640503,
+      "eval_runtime": 32.9486,
+      "eval_samples_per_second": 60.701,
+      "eval_steps_per_second": 0.971,
+      "step": 395
+    },
+    {
+      "epoch": 0.60672,
+      "grad_norm": 2.8829078674316406,
+      "learning_rate": 2.197724039829303e-05,
+      "loss": 0.4014,
+      "step": 474
+    },
+    {
+      "epoch": 0.60672,
+      "eval_cosine_accuracy@1": 0.6365,
+      "eval_cosine_accuracy@10": 0.876,
+      "eval_cosine_accuracy@3": 0.771,
+      "eval_cosine_accuracy@5": 0.8255,
+      "eval_cosine_map@100": 0.5197156334384408,
+      "eval_cosine_mrr@10": 0.7141259920634916,
+      "eval_cosine_ndcg@10": 0.601418022062486,
+      "eval_cosine_precision@1": 0.6365,
+      "eval_cosine_precision@10": 0.26645,
+      "eval_cosine_precision@3": 0.48833333333333334,
+      "eval_cosine_precision@5": 0.3937,
+      "eval_cosine_recall@1": 0.22605882194620797,
+      "eval_cosine_recall@10": 0.6025888884821827,
+      "eval_cosine_recall@3": 0.42357208114816375,
+      "eval_cosine_recall@5": 0.509917211803928,
+      "eval_loss": 0.3428954482078552,
+      "eval_runtime": 33.015,
+      "eval_samples_per_second": 60.579,
+      "eval_steps_per_second": 0.969,
+      "step": 474
+    },
+    {
+      "epoch": 0.70784,
+      "grad_norm": 2.7049639225006104,
+      "learning_rate": 1.6358463726884778e-05,
+      "loss": 0.3779,
+      "step": 553
+    },
+    {
+      "epoch": 0.70784,
+      "eval_cosine_accuracy@1": 0.6455,
+      "eval_cosine_accuracy@10": 0.8815,
+      "eval_cosine_accuracy@3": 0.784,
+      "eval_cosine_accuracy@5": 0.8345,
+      "eval_cosine_map@100": 0.5322933983250332,
+      "eval_cosine_mrr@10": 0.7239722222222216,
+      "eval_cosine_ndcg@10": 0.6129085102767301,
+      "eval_cosine_precision@1": 0.6455,
+      "eval_cosine_precision@10": 0.27020000000000005,
+      "eval_cosine_precision@3": 0.49716666666666665,
+      "eval_cosine_precision@5": 0.39830000000000004,
+      "eval_cosine_recall@1": 0.2337385415837256,
+      "eval_cosine_recall@10": 0.6114790331062327,
+      "eval_cosine_recall@3": 0.43581210236649,
+      "eval_cosine_recall@5": 0.5201249831864138,
+      "eval_loss": 0.32787367701530457,
+      "eval_runtime": 33.0268,
+      "eval_samples_per_second": 60.557,
+      "eval_steps_per_second": 0.969,
+      "step": 553
+    },
+    {
+      "epoch": 0.80896,
+      "grad_norm": 2.0675265789031982,
+      "learning_rate": 1.073968705547653e-05,
+      "loss": 0.3463,
+      "step": 632
+    },
+    {
+      "epoch": 0.80896,
+      "eval_cosine_accuracy@1": 0.656,
+      "eval_cosine_accuracy@10": 0.889,
+      "eval_cosine_accuracy@3": 0.793,
+      "eval_cosine_accuracy@5": 0.839,
+      "eval_cosine_map@100": 0.5425920958735082,
+      "eval_cosine_mrr@10": 0.7340821428571421,
+      "eval_cosine_ndcg@10": 0.6223116530478937,
+      "eval_cosine_precision@1": 0.656,
+      "eval_cosine_precision@10": 0.27415,
+      "eval_cosine_precision@3": 0.504,
+      "eval_cosine_precision@5": 0.4019000000000001,
+      "eval_cosine_recall@1": 0.23843478790276604,
+      "eval_cosine_recall@10": 0.6201721618621493,
+      "eval_cosine_recall@3": 0.442197840531875,
+      "eval_cosine_recall@5": 0.5237564546607093,
+      "eval_loss": 0.30987244844436646,
+      "eval_runtime": 33.1417,
+      "eval_samples_per_second": 60.347,
+      "eval_steps_per_second": 0.966,
+      "step": 632
+    },
+    {
+      "epoch": 0.91008,
+      "grad_norm": 1.9332996606826782,
+      "learning_rate": 5.120910384068279e-06,
+      "loss": 0.3202,
+      "step": 711
+    },
+    {
+      "epoch": 0.91008,
+      "eval_cosine_accuracy@1": 0.6545,
+      "eval_cosine_accuracy@10": 0.89,
+      "eval_cosine_accuracy@3": 0.7925,
+      "eval_cosine_accuracy@5": 0.841,
+      "eval_cosine_map@100": 0.5411107394124216,
+      "eval_cosine_mrr@10": 0.7325833333333327,
+      "eval_cosine_ndcg@10": 0.6220169640997574,
+      "eval_cosine_precision@1": 0.6545,
+      "eval_cosine_precision@10": 0.27425,
+      "eval_cosine_precision@3": 0.5031666666666667,
+      "eval_cosine_precision@5": 0.4011,
+      "eval_cosine_recall@1": 0.23852962917260728,
+      "eval_cosine_recall@10": 0.6212349911293668,
+      "eval_cosine_recall@3": 0.4422107764041644,
+      "eval_cosine_recall@5": 0.5245186089315591,
+      "eval_loss": 0.29744598269462585,
+      "eval_runtime": 33.0411,
+      "eval_samples_per_second": 60.531,
+      "eval_steps_per_second": 0.968,
+      "step": 711
+    }
+  ],
+  "logging_steps": 79,
+  "max_steps": 782,
+  "num_input_tokens_seen": 0,
+  "num_train_epochs": 1,
+  "save_steps": 79,
+  "stateful_callbacks": {
+    "TrainerControl": {
+      "args": {
+        "should_epoch_stop": false,
+        "should_evaluate": false,
+        "should_log": false,
+        "should_save": true,
+        "should_training_stop": true
+      },
+      "attributes": {}
+    }
+  },
+  "total_flos": 0.0,
+  "train_batch_size": 64,
+  "trial_name": null,
+  "trial_params": null
+}

training_args.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cdea35d0724c9e06d3f852a4286ce48146ba93db37ca02f0e361541763ae50b7
+size 6097