Add new SentenceTransformer model

.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,1484 @@
+---
+tags:
+- sentence-transformers
+- sentence-similarity
+- feature-extraction
+- generated_from_trainer
+- dataset_size:482743
+- loss:MultipleNegativesRankingLoss
+base_model: Alibaba-NLP/gte-multilingual-base
+widget:
+- source_sentence: 바르샤바 메커니즘은 별도의 어떤 것을 설치하는 것이 핵심일까
+  sentences:
+  - COP19에서 주목되는 것은 기후변화로 야기되는 개도국들의 손실과 피해에 관한 ‘바르샤바 메커니즘(Warsaw International Mechanism
+    for Loss and Damage Associated with Climate Change Impacts)’을 새로이 출범시키기로 합의한 점이다.
+    이에 따라 2014년 개도국의 기후변화로 인한 ‘손실과 피해’ 의제에 대한 UN 차원의 논의가 더욱 강화될 전망이다. 개도국들이 적극적으로
+    옹호하는 ‘손실과 피해’는 기후변화의 부정적 영향으로 인해 발생하는 자연재해와 같은 극한 기후현상 및 해수면 상승 등 서서히 발생하는 피해(slow-onset
+    event)를 의미한다. 바르샤바 메커니즘은 △개도국의 기후변화로 인한 손실과 피해에 대한 위험관리, △관련 기구와 조직, 이해관계자 간 연계,
+    △재원‧기술 지원 등의 역할을 하는 별도의 집행위원회를 설치하는 것이 핵심이다.
+  - 북한은 중앙집권적이고 폐쇄적인 사회이기 때문에 한국과 전면적인 사회문화교류를 진행하는 것이 체제유지 차원에서 큰 부담이었다. 이에 인도적 지원사업이나
+    경제협력에 비하여 사회문화교류에 대해서는 소극적인 태도를 취했던 것이다. 또 북한은 정치적 성격이 짙은 사업이나 경제적 대가를 받을 수 있는
+    사업을 우선시하는 경향이 있어, 실익이 크지 않은 이벤트성 사회문화 교류사업은 성사되기 어려운 환경이었다. 이러한 경험을 통해 지자체들은 2002년부터
+    북한 당국이 필요로 하는 인도적 지원사업을 보다 적극적으로 추진하였다. 지자체 교류협력 초기 강원도와 제주 도가 추진한 인도적 지원 사업이
+    성과를 낸 것도 이러한 방향전환에 일조하였다. 또한 2002년 지방선거로 새로이 출범한 광역단체장들이 남북교류협력에 적극 나서기 시작한 것도
+    우호적인 환경이 되었다.
+  - 충남 보령시는 지난 29일 종합사회복지관에서 50가정이 참여한 가운데 자녀와 함께하는 우리가족 봄김장 담그기 행사를 개최했다고 밝혔다. 이번
+    행사는 가족 TV 프로그램에 출연하여 천연 요리연구가로 명성이 높은 박상혜 요리연구가와 함께 우리 전통음식 김치의 영양학적 가치 및 김치 담그는
+    법을 알아보는 시간을 가졌다. 이어 참여한 아동들이 카네이션 꽃과 마음의 편지를 부모님께 전달하는 등 5월 가정의 달을 맞아 가족의 소중함을
+    일깨우는 시간도 마련됐다. 특히 체험에 함께하지 못한 주변 어려운 이웃 50가정에게 전달할 김치를 추가로 담아 나눔을 실천함으로써 참가자들이
+    재능 기부의 주체가 되는 훈훈함도 선보였다. 이날 행사는 코로나19 방역 수칙을 철저히 준수하며 사회적거리 유지를 위해 오전, 오후 2회에
+    걸쳐 25가정씩 진행했다. 행사에 참여한 최모씨는 "아이와 함께 담근 김장이라 더 맛있게 느껴질 것 같다"며 "가족간의 정도 쌓고 주변 이웃에게도
+    나눌 수 있어 매우 뜻깊은 시간이었다"고 전했다. 김동일 시장은 "모두가 힘든 시기를 지내고 있는 요즘, 어려운 가정의 사소한 부분까지 세심하게
+    채워줄 수 있는 좋은 프로그램을 지속적으로 개발하여 부모가 행복하고 아이 키우기 좋은 보령시를 만들겠다"고 말했다.
+- source_sentence: 고등교육 재정을 무엇의 기준에서 살펴보면 교육비가 낮다는 문제점을 지적할 수 있지
+  sentences:
+  - 춤과 노래를 좋아하는 에너지 넘치는 은채는 식당을 운영하는 엄마의 돌봄을 거의 받지 못한다. 코로나19로 손님이 끊긴 엄마의 한숨과 스트레스는
+    잔소리로 은채에게 쏟아진다. 매일 핀잔을 들은 은채는 답답한 현실을 도피하기 위해 친구들을 소집한다. 은채와 비슷한 고민을 하는 친구들은 어릴
+    적 가족들과 행복했던 추억의 순간을 기억하며 무작정 바다를 찾아 떠난다. 하지만 바다를 찾아가는 과정이 순탄치만은 않다. 광주에서 최초로 어린이들이
+    직접 주인공으로 참여한 독립영화 '바다로 간 아이들' 이 제작을 마치고 시사회를 갖는다. 영화는 지역의 문화예술교육 전문 단체인 문화공동체
+    아우름이 주관 운영하고 있는 사회공헌 문화예술교육 프로젝트 '기아챌린지 어린이 뮤지컬' 팀의 2020년 교육프로그램 �� 하나로 제작됐다. 기아자동차
+    광주공장과 초록우산은 후원자로 나섰다. '기아챌린지 어린이 뮤지컬' 팀은 2016년에 창단됐다. 광주지역아동센터에 소속된 어린이들 중 춤,
+    노래, 연기 등 예술재능이 뛰어난 어린이들을 매년 모집해 운영된다. 기아챌린지 어린이 뮤지컬 팀은 창단된 해인 2016년, 창작뮤지컬 '그래도
+    괜찮아'를 선보인바 있으며, 2019년에는 창작뮤지컬 '내가 가는 길'을 무대에 올려 호평을 받았다. 올해에도 새로운 창작뮤지컬을 목표로 지난해부터
+    준비해 왔으나 코로나19로 인해 매주 모여서 연습할 수 없는 상황이 연속됐다. 제작진과 출연진들은 화상회의 어플인 '줌'을 통해 각자 춤과
+    노래, 연기 합을 맞췄다. 시간이 흐를수록 집중력이 떨어지고 무엇보다 춤과 관련된 동작은 완벽하게 합을 맞추는 것이 불가능했다. 온라인 교육의
+    한계를 극복할 수 있는 방안을 고민하던 제작진과 출연진들은 대안으로 영화제작을 떠올렸다. 영화 배역에 따른 모든 과정은 온라인으로 교육받을
+    수 있었다. 영화제작은 지역에서 오랫동안 독립영화를 제작 배급해 온 '필름에이지' 가 맡았다. 코로나 시대 어린이들이 맞닥뜨린 현실과 그에
+    대한 여러 가지 감정들을 출연진들과 직접 소통하면서 성장드라마 형식의 독립영화 '바다로 간 아이들'이 완성됐다. 영화 '바다로 간 아이들'은
+    한 번도 경험해 보지 못한 새로운 일상에 모두가 지쳐가고 있는 현 시대를 그대로 보여준다. 특히 학교에 가지 못하고 집에서 고립된 우리 아이들,
+    집중력이 떨어지는 온라인 수업과 넘쳐나는 에너지를 분출 할 수 없는 답답함에 힘들어 하는 미래 세대들의 목소리에 귀를 기울이고 있다. 필름에이지
+    윤수안 감독과 제작진은 어린이들과 직접 만나 코로나 시대를 보내는 어린이들의 일상과 감정들을 스토리텔링 했고 그 내용을 바탕으로 시나리오를
+    완성했다. 특히 영화에 출연하는 어린이들의 예술적 에너지를 표출할 수 있는 뮤직비디오 형식의 댄스가 영화에 가미돼 완성도를 높였다. 영화는
+    오는 23일 오후3시 광주독립영화관에서 시사회를 통해 관계자들에 첫 선을 보일 예정이다. 이후 공식적인 극장 배급을 통해 관객들에게 찾아간다.
+    향후 국내 영화제에도 출품될 계획이다.
+  - 고등교육 재정 지원 정책을 진단하는 준거로 충족성, 안정성, 자율성, 합리성 등(서영인 외, 2017)을 사용해 고등교육 재정의 문제점을 살펴보면
+    다음과 같다. 첫째, 충족성의 기준에서 고등교육 재정을 살펴보면, 우선 낮은 교육비의 문제점을 들 수 있다. 2017년 조사된 OECD 대학생
+    1인당 교육비 자료를 보면, 복지국가인 북유럽이나 우리와 마찬가지로 고등교육비용의 수익자부담 원칙이 강한 영국, 미국, 일본의 1인당 교육비는
+    약 2만불 이상(일본은 $18,022)으로 매우 높으나 한국은 $9,570으로 평균 이하의 매우 낮은 그룹에 속해 있는 것을 알 수 있다.
+    고등교육에 대한 투자가 교육경쟁력은 물론 국가의 경제 발전을 선도할 수 있는 필수조건임을 고려할 때 고등교육 재정에 대한 투자의 확대가 필요하다.
+  - 청와대가 유효일 국방차관의 5.18 행적논란과 관련해 극히 신중한 자세를 보이고 있다. 5.18 관련 시민단체와 민주당에 이어 열린우리당내
+    일부 호남 의원이 유 차관경질을 요구하고 나섰지만, 국방부 조사 결과를 지켜보고 판단하겠다는 기존 입장에서 크게 달라진 것은 없다. 청와대는
+    특히 유 차관 행적에 대한 국방부 조사결과가 나와도 노무현대통령에 대한 별도 보고가 없을 것이란 입장을 밝히고 나서 주목된다. 청와대 고위관계자는
+    26일 연합뉴스와 통화에서 "조사 결과가 나와도 대통령에게 보고할 성질이 아니라고 본다"며 "비서실장과 민정수석, 인사수석 등이 내용을정확히
+    확인하고 판단을 내릴 것"이라고 말했다. 이 관계자는 또 일부 언론에서 거론하고 있는 유 차관 거취 문제에 대해 "청와대에선 전혀 검토한 적이
+    없다"며 "논의할 단계도 아니다"고 말했다. 한 핵심관계자는 "유 차관의 과거 행적과 관련해 만일 특별한 내용이 있다면 서면보고가 이뤄질지
+    몰라도 소관 장관이 대통령에게 직접 보고할 가능성은 없을 것 같다"고 말했다. 청와대가 이처럼 유 차관 문제에 대해 신중한 자세를 견지하고
+    있는 것은 5.18당시 광주지역에 투입된 20사단 소속 대대장이었던 유 차관의 예하 부대가 시민군과충돌하거나 인명살상 등 진압작전을 직접 수행했다는
+    명백한 증거가 아직 나오지 않다는 점이 감안된 것으로 알려졌다. 특히 이런 상황에서 청와대가 직접 나서 유 차관에 대한 거취 문제를 거론할
+    경우 공직사회, 특히 군이 심리적으로 동요할 수 있다는 점도 작용한 것으로 보인다. 한 관계자는 "시민단체가 요구한다고 해서 이미 검찰 조사에서
+    문제가 없는 것으로 판단이 내려진 사안을 갖고 섣불리 한 부처의 차관을 경질한다면 공직사회의지휘체계가 동요할 수 밖에 없다"고 말했다.
+- source_sentence: DCM 벅 변환기는 모바일 기기에 적용되며 이를 제작한 공정은 무엇이지?
+  sentences:
+  - 오리엔탈정공(014940)은 상한가를 기록하고 있다. 동종목은 현재 1,445원선에서 이루어지고 있다. 참고로 52주 최고가는 2,545원(17년
+    05월 02일), 최저가는 960원(17년 12월 22일)원이다. 최근 3일동안 평균 거래량은 234만 주이다. 이는 250일 일 평균 거래량
+    80만 주와 비교해보면 최근 거래량이 급격히 늘어났다는 것을 알 수 있다. 외국인과 기관은 순매도, 개인은 순매수(한달누적) 전일까지 외국인이
+    4일 연속, 기관이 11일 연속 각각 동종목을 순매도 했다. 4주간을 기준으로 보면 외국인이 매도 우위를 지속하면서 41,454주를 순매도했고,
+    기관도 매도 관점으로 접근하면서 218주를 순매도했지만, 개인은 오히려 순매수량을 늘리며 41,672주를 순매수했다. 외국인, 기관 모두 보유량
+    감소 (5일 누적) 최근 5일간 동종목의 외국인 투자자는 13,169주 순매도하였고 마찬가지로 기관은 4주 순매도하였다. 전날 두 주체 각각
+    7,143주, 4주 순매도하며 보유 비율을 줄였다. 다음 표는 동종목의 외국인, 기관의 일별 순매수량을 나타낸 것이다. fnRASSI는 증권전문
+    기업 씽크풀과 파이낸셜뉴스의 협업으로 로봇기자가 실시간으로 생산하는 기사입니다.
+  - '산업부, 글로벌전문기술개발사업에 1,565억원 지원
+
+    □ 산업통상자원부(장관 윤상직)는 국내 중소․중견기업의 기술경쟁력 강화를 통해 글로벌전문기업으로 육성하기 위한 ‘2014년도 글로벌 전문기술개발사업(주력
+    및 신산업)‘의 신규 지원계획을 공고함
+
+    ㅇ 동 사업은 글로벌 기술경쟁력을 보유한 우수 중소·중견기업을육성하는 산업부의 대표 R&D사업으로, 지원 규모는 과제 특성에따라 최대 5년
+    이내에서 매년 2~10억원 규모임 □ 2014년 글로벌전문기술개발사업(주력 및 신산업) 지원 예산 1,565억원 중 금번 신규 지원 공고대상은
+    5개 내역사업, 413억원 규모임
+
+    ㅇ 섬유생활스트림, 해양레저장비, 개인용이동수단, 청정생산기반 등 4개 사업의 신규 예산은 223억원으로,
+
+    - 품목지정형 과제* 32개에 153.29억원을 지원하며,
+
+    * 품목 : 단위 기술이 아닌 ‘주요 성능을 포함한 제품 혹은 제품군’을 의미
+
+    - (예) 고기능성 친환경 벽지제품, 휴대용 접이식 전기자전거, 등
+
+    * 품목지정형 과제수 : 섬유생활스트림 25개, 해양레저장비 2개, 개인용 이동수단 2개, 청정생산기반 3개
+
+    - 자유공모형 과제는 섬유생활스트림, 해양레저장비, 청정생산기반 등 3개 사업에서 69.67억원을 지원함
+
+    ㅇ 우수기술연구센터(ATC) 사업은 자유공모형 과제를 지원하며, 우수 중소·중견기업 부설연구소 40개 내외를 선정하여 190억원을 지원함'
+  - <h1>요 약</h1><p>본 논문에서 모바일 기기에 적용하는 DCM DC-DC 벅 변환기를 설계하였다. 이 변환기는 안정된 동작을 위한 보상기,
+    PWM 로직과 파워 스위치로 구성되어 있다. 작은 하드웨어 폼-팩터를 얻기 위하여 칩 외부에서 사용하는 소자의 갯수를 최소화하여야 하며 이는
+    효율적인 주파수 보상과 디지털 스타트-업 회로로 구현하였다. 매우 작은 부하 전류에서 효율의 감소를 막기 위하여 버스트-모드 동작도 구현하였다.
+    DCM 벅 변환기는 0.18um BCDMOS 공정으로 제작되었다. \ ( 2.8 \sim 5 \mathrm{V} \) 의 입력 전압 범위에
+    대하여 출력 전압 값은 외부 저항 소자를 사용하여 \( 1.8 \mathrm{V} \) 로 프로그램 되었다. \ ( 1 \mathrm{MHz}
+    \) 의 스위칭 주파수 및 \( 100 \mathrm{mA} \) 의 부하 전류에서 측정된 최대 효율은 \( 92.6 \% \) 이다. </p>
+- source_sentence: 생활안전지도 이벤트는 6월 28일부터 몇 개월간 진행할 계획이니
+  sentences:
+  - '내 주변 안전은 생활안전지도에서 확인하세요. - 올 상반기 서비스 이용률 전년대비 2.5배 상승, 6.28일부터 퀴즈 이벤트 실시 -
+
+    □ 행정안전부(장관 김부겸)는 생활안전지도를 통해 범죄 발생현황, 교통사고 발생현황, 대피시설 정보, 미세먼지 등 각종 내 주변의 안전정보를
+    한 곳에 모아 알기 쉬운 지도형태로 정보(239종)를 제공하고 있다. ○ 특히, 생활안전지도에서는 등·하굣길·출근길 교통사고 주의구간, 우리
+    동네 안전한 대피소, 안전 녹색길, 어린이 안전지도, 여성밤길 및 노인 안전지도 등을 내 위치 기반으로 쉽게 확인할 수 있다. □ 또한, 공공·민간분야
+    설문조사, 발전방안에 대한 전문가 의견수렴, 공동이용 협의회 운영을 통한 서비스 개선방안을 모색하고 있다. ○ 생활안전지도 누리집(safemap.go.kr)을
+    통해 서비스 이용 현황을 공개하고, 안전정보의 공개 근거 마련을 위해 재난 및 안전관리 기본법 개정안을 입법예고 중에 있다. ○ 앞으로, 생활안전지도
+    정보를 학교안전교육에 활용할 수 있도록 지도교사용 안전교육 안내서도 마련하여 제공할 계획이다. □ 유용한 생활안전지도 정보를 보다 많은 국민들이
+    이용할 수 있도록 서비스를 널리 알리기 위해 ‘생활안전지도 퀴즈 이벤트’를 6월 28일 부터 4개월 동안 진행할 계획이다.'
+  - 33살에 임원 38살에 최고경영자 국내 재벌그룹에서 경영권 승계가 진행 중이거나 최근에 끝난 재벌총수 3~4세들이 처음 임원이 되는 나이는
+    평균 33살, 사장이나 회장 등 최고경영자의 지위에 오르는 나이는 평균 38살로 조사됐다. 또 이들 재벌 3~4세들이 입사해 최고경영자가 되는
+    데 걸리는 기간은 평균 11년 정도인 것으로 나타났다. 최근 일부 그룹 총수 일가의 초고속 승진이 사회적으로 주목을 받고 있는 가운데, 에서
+    경영승계가 진행되고 있거나 최근에 끝난 삼성, 엘지, 현대·기아차, 에스케이, 한진, 롯데, 두산, 신세계, 씨제이, 효성, 코오롱, 현대백화점
+    등 12개 주요 그룹의 재벌총수 3~4세(한진·롯데는 2세) 36명을 대상으로 경영승계 실태를 조사했더니 이렇게 나타났다. 조상 대상은 삼성에선
+    이재용 삼성전자 상무 등 5명, 엘지는 구본걸 엘지상사 부사장 등 3명, 현대·기아차는 정의선 기아차 사장 등 4명, 에스케이는 최태원 에스케이㈜
+    회장 등 4명, 한진은 조양호 회장 등 4명, 롯데는 신동빈 부회장, 두산은 박정원 ㈜두산 사장 등 5명, 신세계는 정용진 부사장 등 2명,
+    씨제이는 이재현 회장 등 2명, 효성은 조현준 부사장 등 3명, 코오롱은 이웅렬 회장, 현대백화점은 정지선 부회장 등 2명이다. 12개 그룹
+    총수 3~4세 36명 조사 입사 11년만에 최고경영자 ‥ “능력검증 필요” 조사 결과, 재벌 3~4세들은 평균 27.3살에 계열사에 입사한
+    뒤, 32.8살에 처음 임원에 임명됐다. 임원이 되는 데 걸린 기간은 평균 5.5년이었다. 재벌 3~4세 중에서 이미 사장 이상 직급(회장,
+    부회장 포함)을 맡고 있거나, 직급은 이에 못미치지만 대표이사를 맡아 사실상 최고경영자 노릇을 하고 있는 17명이 최고경영자에 오른 나이는
+    평균 38.2살이었다. 최고경영자 지위까지 오르는 데 걸린 기간은 입사 시점을 기준으로 하면 10.8년, 첫 임원 임명을 기준으로 하면 6.4년이었다.
+    또 삼성 이건희 회장과 엘지 구본무 회장, 현대·기아차의 정몽구 회장, 한화의 김승연 회장, 금호아시아나의 박삼구 회장, 두산의 박용오·용성
+    회장, 효성의 조석래 회장 등 주요 그룹의 현직 재벌총수 8명은 평균 28.2살에 계열사에 들어온 뒤, 30.2살에 임원으로 승진하고, 37.5살에
+    최고경영자에 선임된 것으로 나타났다. 재벌 3~4세들과 현직 재벌총수들을 비교하면, 임원 승진 나이는 2년 정도 늦어졌으나, 최고경영자로 선임되는
+    나이는 비슷하다. 정광선 한국기업지배구조 개선지원센터 원장(중앙대 교수)은 “재벌총수 일가의 초고속 승진과 조급한 경영승계는 기업을 위험에
+    빠뜨릴 수 있는 만큼 충분한 경영수업과 경영능력에 대한 객관적 검증이 필요하다”고 말했다. 곽정수 대기업전문기자
+  - '국회미래연구원 EPTA(유럽의회 기술영향평가) 네트워크 가입
+
+    ■ EPTA 가입의 의의
+
+    EPTA는 유럽 각국의 의회 중심으로 신기술에 관한 자문을 제공하는 기술영향평가 기관 네트워크로서 올해의 의장국인 스웨덴을 비롯하여 유럽의
+    12개국(Full member) 및 미국을 비롯한 유럽 이외의 10개(Associate Member)의 국가가 참여하고 있다. 유럽 이외의
+    국가의 경우 Full Membership이 부여되지 않는다. EPTA는 과학기술의 발달이 사회에 미치는 영향을 사전에 예측하고 대응함으로써,
+    긍정적인 효과를 극대화하고 부정적인 영향을 최소화하는 목적이 있으며 공동의 아젠다를 확정하고 연구를 진행함으로써 글로벌 이슈에 대한 각국의
+    상세 연구결과를 공유하고 있다. 기술영향평가는 1970년대 미국에서 과학기술을 연구자, 관련 전문가 및 국민이 참여하는 민주적 평가 방식을
+    통해 기술의 발전에 선제적으로 대응하기 위해 실시되었다. 미국은 1974년 OTA(Office of Technology Assessment)를
+    두고 전문가 중심의 기술영향 평가를 시행하였으며, 1995년 OTA가 폐지된 후 현재는GAO(Government Accountability
+    Office)에서 맡아 운영되고 있다. 유럽의 경우 유럽 최초의 공식적인 기술영향평가 기관으로 1983년 프랑스의OPECST(Office Parlementaire
+    d’Evaluation des Choix Scientifique Technologie)를 시작으로 영국, 네덜란드, 덴마크, 독일, 스위스
+    등 유럽 각국에서 다양한 형태와 방법으로 기술영향평가를 도입하여 수행되고 있다. EPTA는 1990년에 설립되어 다양한 주제에 대한 유럽 각국의
+    기술영향평가 결과를 공유하고 이를 통해 유럽의회에 의견을 개진함으로써, 관련 법령 제정 및 정책 추진에 있어서 중요한 방향을 제시하고 있다.
+    지난 10월 10-11일 스웨덴 의회에서 개최된 EPTA 컨퍼런스에서는 “Technologies in care for older people”을
+    주제로 유럽뿐만 아니라 미국을 비롯한 다양한 국가에서 관련 내용을 발표하였다. 특히, 일본에서는 노인을 지원하는 다양한 로봇의 실물과 사진
+    전시를 통해 초고령사회로 들어선 일본의 노인 지원을 위한 다양한 기술의 진보를보여주었다.'
+- source_sentence: LPGA 투어에서 고진영이 컷 탈락을 기록한 건 얼마나 돼
+  sentences:
+  - '1회용품 함께 줄이기 계획
+
+    Ⅰ. 추진 배경
+
+    □ (그간 추진 경과) ‘자원의 절약 및 재활용 촉진에 관한 법률’에 따라 1회용품 사용억제 제도 운영(1994~, 18개품목-18개업종)
+
+    o (성과) 「재활용 폐기물 관리 종합대책」(2018.5)을 수립하고 1회용컵, 비닐봉투 사용저감을 집중 추진하여 일정 감축성과 창출
+
+    * 커피전문점 매장 내 1회용컵 75% 감소, 제과점 1회용 비닐봉투 84% 감소 등
+
+    o (한계) 그러나 국민이 체감할 변화는 아직 미흡하며, 비 규제 품목(빨대 등) 및 유형(배달 등)에 대한 관리 강화 요구 증가
+
+    □ (해외 동향) 세계 각 국은 1회용품 사용을 저감하기 위한 중장기 로드맵을 발표하고, 국가별로 다양한 규제방안 도입
+
+    * EU는 1회용 플라스틱 10대 품목 선정, 품목별 시장출시 금지 등 규제방안 마련
+
+    ** 미국 일부 州, 캐나다, 프랑스, 케냐, 칠레 등 1회용 비닐봉투 등 사용금지 도입'
+  - 노인에게 적절한 일자리를 제공하는 것을 목적으로 하는 노인의 경제 활동 지원 정책은 고용과 복지로 이원화되어 진행된다는 전달체계상의 문제가
+    있으며, 다른 영역에 비하여 노인일자리사업의 불충분성(수요는 현재 공급량에 비해 약 4배 이상)이 크다. 더불어 사업 대상의 욕구와 사업 구조의
+    불일치성이 큰데, 이는 지금까지의 관련 정책이 공공 영역 중심으로 이루어졌다는 점이 주요 원인 중 하나이다. 활기찬 노후 생활을 영위할 수
+    있도록 지원하는 노인 여가활동 지원 정책은 정책의 발달 단계상 다른 영역에 비하여 충분성이 매우 낮은 수준이다. 즉, 다양한 여가활동에서의
+    미충족 욕구가 발생하고 있다. 그러나 이러한 불충분성의 문제는 공적 영역만으로는 해결될 수 없다. 또한 노인의 다양성 증대에 따라서 현재 공적
+    영역 정책이 다양한 여가활동 욕구를 충족시키지 못하고 있는 상황이다. 또한 형평성이라는 관점에서 볼 때 형평성이 낮은 인프라 분포로 인하여
+    지역별 형평성의 문제가 있으며, 실질적인 서비스 이용에 있어 성별 차이와 소득수준별 차이가 매우 큰 상황이다.
+  - 여자골프 세계랭킹 1위 고진영(26)이 미국여자프로골프(LPGA) 투어 드라이브온 챔피언십(총상금 150만 달러)에서 컷 탈락했다. 고진영은
+    6일(한국시간) 미국 플로리다주 오칼라의 골든 오칼라 골프 클럽(파72ㆍ6,526야드)에서 열린 대회 2라운드에서 버디와 보기 하나씩을 묶어
+    이븐파 72타를 쳤다. 1라운드 3오버파 75타로 공동 86위에 그쳤던 고진영은 이틀간 합계 3오버파 147타로 공동 72위에 머물러 컷을
+    통과하지 못했다. 컷은 2오버파 146타였다. 고진영이 LPGA 투어 대회에서 컷 탈락한 건 세 번째다. 앞서 2017년 3월 ANA 인스피레이션,
+    2018년 8월 브리티시여자오픈에서 컷을 통과하지 못했다. 그리고 2년 7개월 만에 또 한 번 컷 탈락이 기록됐다. 이날 2라운드는 10번
+    홀에서 시작, 15번 홀(파3) 버디를 잡아냈으나 17번 홀(파4) 보기를 써내 전반 타수를 줄이지 못했고, 후반엔 9개 홀 모두 파를 기록했다.
+    그는 이날 페어웨이는 한 번밖에 놓치지 않았으나 그린을 6차례 놓치고 퍼트 수가 30개에 달했다. 리더보드 맨 위엔 10언더파 134타의 제니퍼
+    컵초, 오스틴 언스트(이상 미국)가 이름을 올린 가운데 데일리 베스트인 7언더파를 몰아친 카를로타 시간다(스페인ㆍ8언더파 136타)가 두 타
+    차로 추격했다. 한국 선수 중에는 허미정(32)이 3언더파 141타, 공동 11위로 가장 좋은 성적을 냈다. 세계랭킹 2위 김세영(28)은
+    공동 17위(2언더파 142타), 전인지(27)는 공동 24위(1언더파 143타)에 자리했다. 정은(25)은 5타, 박성현(28)은 한 타를
+    잃고 공동 58위(2오버파 146타)에 올라 가까스로 컷을 통과했다.
+pipeline_tag: sentence-similarity
+library_name: sentence-transformers
+---
+
+# 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). 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 7fc06782350c1a83f88b15dd4b38ef853d3b8503 -->
+- **Maximum Sequence Length:** 512 tokens
+- **Output Dimensionality:** 768 tokens
+- **Similarity Function:** Cosine Similarity
+<!-- - **Training Dataset:** Unknown -->
+<!-- - **Language:** Unknown -->
+<!-- - **License:** Unknown -->
+
+### Model Sources
+
+- **Documentation:** [Sentence Transformers Documentation](https://sbert.net)
+- **Repository:** [Sentence Transformers on GitHub](https://github.com/UKPLab/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': 512, 'do_lower_case': False}) with Transformer model: 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("seongil-dn/gte-noneg-bs512-lr5e-5-1000")
+# Run inference
+sentences = [
+    'LPGA 투어에서 고진영이 컷 탈락을 기록한 건 얼마나 돼',
+    '여자골프 세계랭킹 1위 고진영(26)이 미국여자프로골프(LPGA) 투어 드라이브온 챔피언십(총상금 150만 달러)에서 컷 탈락했다. 고진영은 6일(한국시간) 미국 플로리다주 오칼라의 골든 오칼라 골프 클럽(파72ㆍ6,526야드)에서 열린 대회 2라운드에서 버디와 보기 하나씩을 묶어 이븐파 72타를 쳤다. 1라운드 3오버파 75타로 공동 86위에 그쳤던 고진영은 이틀간 합계 3오버파 147타로 공동 72위에 머물러 컷을 통과하지 못했다. 컷은 2오버파 146타였다. 고진영이 LPGA 투어 대회에서 컷 탈락한 건 세 번째다. 앞서 2017년 3월 ANA 인스피레이션, 2018년 8월 브리티시여자오픈에서 컷을 통과하지 못했다. 그리고 2년 7개월 만에 또 한 번 컷 탈락이 기록됐다. 이날 2라운드는 10번 홀에서 시작, 15번 홀(파3) 버디를 잡아냈으나 17번 홀(파4) 보기를 써내 전반 타수를 줄이지 못했고, 후반엔 9개 홀 모두 파를 기록했다. 그는 이날 페어웨이는 한 번밖에 놓치지 않았으나 그린을 6차례 놓치고 퍼트 수가 30개에 달했다. 리더보드 맨 위엔 10언더파 134타의 제니퍼 컵초, 오스틴 언스트(이상 미국)가 이름을 올린 가운데 데일리 베스트인 7언더파를 몰아친 카를로타 시간다(스페인ㆍ8언더파 136타)가 두 타 차로 추격했다. 한국 선수 중에는 허미정(32)이 3언더파 141타, 공동 11위로 가장 좋은 성적을 냈다. 세계랭킹 2위 김세영(28)은 공동 17위(2언더파 142타), 전인지(27)는 공동 24위(1언더파 143타)에 자리했다. 정은(25)은 5타, 박성현(28)은 한 타를 잃고 공동 58위(2오버파 146타)에 올라 가까스로 컷을 통과했다.',
+    '1회용품 함께 줄이기 계획\nⅠ. 추진 배경\n□ (그간 추진 경과) ‘자원의 절약 및 재활용 촉진에 관한 법률’에 따라 1회용품 사용억제 제도 운영(1994~, 18개품목-18개업종)\no (성과) 「재활용 폐기물 관리 종합대책」(2018.5)을 수립하고 1회용컵, 비닐봉투 사용저감을 집중 추진하여 일정 감축성과 창출\n* 커피전문점 매장 내 1회용컵 75% 감소, 제과점 1회용 비닐봉투 84% 감소 등\no (한계) 그러나 국민이 체감할 변화는 아직 미흡하며, 비 규제 품목(빨대 등) 및 유형(배달 등)에 대한 관리 강화 요구 증가\n□ (해외 동향) 세계 각 국은 1회용품 사용을 저감하기 위한 중장기 로드맵을 발표하고, 국가별로 다양한 규제방안 도입\n* EU는 1회용 플라스틱 10대 품목 선정, 품목별 시장출시 금지 등 규제방안 마련\n** 미국 일부 州, 캐나다, 프랑스, 케냐, 칠레 등 1회용 비닐봉투 등 사용금지 도입',
+]
+embeddings = model.encode(sentences)
+print(embeddings.shape)
+# [3, 768]
+
+# Get the similarity scores for the embeddings
+similarities = model.similarity(embeddings, embeddings)
+print(similarities.shape)
+# [3, 3]
+```
+
+<!--
+### Direct Usage (Transformers)
+
+<details><summary>Click to see the direct usage in Transformers</summary>
+
+</details>
+-->
+
+<!--
+### Downstream Usage (Sentence Transformers)
+
+You can finetune this model on your own dataset.
+
+<details><summary>Click to expand</summary>
+
+</details>
+-->
+
+<!--
+### Out-of-Scope Use
+
+*List how the model may foreseeably be misused and address what users ought not to do with the model.*
+-->
+
+<!--
+## 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 Hyperparameters
+#### Non-Default Hyperparameters
+
+- `per_device_train_batch_size`: 128
+- `per_device_eval_batch_size`: 128
+- `warmup_steps`: 100
+- `bf16`: True
+
+#### All Hyperparameters
+<details><summary>Click to expand</summary>
+
+- `overwrite_output_dir`: False
+- `do_predict`: False
+- `eval_strategy`: no
+- `prediction_loss_only`: True
+- `per_device_train_batch_size`: 128
+- `per_device_eval_batch_size`: 128
+- `per_gpu_train_batch_size`: None
+- `per_gpu_eval_batch_size`: None
+- `gradient_accumulation_steps`: 1
+- `eval_accumulation_steps`: None
+- `torch_empty_cache_steps`: None
+- `learning_rate`: 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`: 3
+- `max_steps`: -1
+- `lr_scheduler_type`: linear
+- `lr_scheduler_kwargs`: {}
+- `warmup_ratio`: 0.0
+- `warmup_steps`: 100
+- `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`: True
+- `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}
+- `deepspeed`: None
+- `label_smoothing_factor`: 0.0
+- `optim`: adamw_torch
+- `optim_args`: None
+- `adafactor`: False
+- `group_by_length`: False
+- `length_column_name`: length
+- `ddp_find_unused_parameters`: None
+- `ddp_bucket_cap_mb`: None
+- `ddp_broadcast_buffers`: False
+- `dataloader_pin_memory`: True
+- `dataloader_persistent_workers`: False
+- `skip_memory_metrics`: True
+- `use_legacy_prediction_loop`: False
+- `push_to_hub`: False
+- `resume_from_checkpoint`: None
+- `hub_model_id`: None
+- `hub_strategy`: every_save
+- `hub_private_repo`: False
+- `hub_always_push`: False
+- `gradient_checkpointing`: False
+- `gradient_checkpointing_kwargs`: None
+- `include_inputs_for_metrics`: False
+- `eval_do_concat_batches`: True
+- `fp16_backend`: auto
+- `push_to_hub_model_id`: None
+- `push_to_hub_organization`: None
+- `mp_parameters`: 
+- `auto_find_batch_size`: False
+- `full_determinism`: False
+- `torchdynamo`: None
+- `ray_scope`: last
+- `ddp_timeout`: 1800
+- `torch_compile`: False
+- `torch_compile_backend`: None
+- `torch_compile_mode`: None
+- `dispatch_batches`: None
+- `split_batches`: None
+- `include_tokens_per_second`: False
+- `include_num_input_tokens_seen`: False
+- `neftune_noise_alpha`: None
+- `optim_target_modules`: None
+- `batch_eval_metrics`: False
+- `eval_on_start`: False
+- `eval_use_gather_object`: False
+- `batch_sampler`: batch_sampler
+- `multi_dataset_batch_sampler`: proportional
+
+</details>
+
+### Training Logs
+<details><summary>Click to expand</summary>
+
+| Epoch  | Step | Training Loss |
+|:------:|:----:|:-------------:|
+| 0.0011 | 1    | 0.4348        |
+| 0.0021 | 2    | 0.4712        |
+| 0.0032 | 3    | 0.4947        |
+| 0.0042 | 4    | 0.4267        |
+| 0.0053 | 5    | 0.4421        |
+| 0.0064 | 6    | 0.4834        |
+| 0.0074 | 7    | 0.4726        |
+| 0.0085 | 8    | 0.4524        |
+| 0.0096 | 9    | 0.4645        |
+| 0.0106 | 10   | 0.4654        |
+| 0.0117 | 11   | 0.4574        |
+| 0.0127 | 12   | 0.5019        |
+| 0.0138 | 13   | 0.4481        |
+| 0.0149 | 14   | 0.423         |
+| 0.0159 | 15   | 0.4694        |
+| 0.0170 | 16   | 0.4316        |
+| 0.0180 | 17   | 0.4372        |
+| 0.0191 | 18   | 0.4623        |
+| 0.0202 | 19   | 0.4222        |
+| 0.0212 | 20   | 0.4494        |
+| 0.0223 | 21   | 0.3932        |
+| 0.0234 | 22   | 0.3924        |
+| 0.0244 | 23   | 0.3869        |
+| 0.0255 | 24   | 0.4064        |
+| 0.0265 | 25   | 0.3945        |
+| 0.0276 | 26   | 0.382         |
+| 0.0287 | 27   | 0.3684        |
+| 0.0297 | 28   | 0.3881        |
+| 0.0308 | 29   | 0.3784        |
+| 0.0318 | 30   | 0.3715        |
+| 0.0329 | 31   | 0.34          |
+| 0.0340 | 32   | 0.3421        |
+| 0.0350 | 33   | 0.3678        |
+| 0.0361 | 34   | 0.3489        |
+| 0.0372 | 35   | 0.3112        |
+| 0.0382 | 36   | 0.3137        |
+| 0.0393 | 37   | 0.2928        |
+| 0.0403 | 38   | 0.3053        |
+| 0.0414 | 39   | 0.2838        |
+| 0.0425 | 40   | 0.2638        |
+| 0.0435 | 41   | 0.2827        |
+| 0.0446 | 42   | 0.2372        |
+| 0.0456 | 43   | 0.2635        |
+| 0.0467 | 44   | 0.2749        |
+| 0.0478 | 45   | 0.2381        |
+| 0.0488 | 46   | 0.2113        |
+| 0.0499 | 47   | 0.1914        |
+| 0.0510 | 48   | 0.1944        |
+| 0.0520 | 49   | 0.1863        |
+| 0.0531 | 50   | 0.191         |
+| 0.0541 | 51   | 0.1547        |
+| 0.0552 | 52   | 0.1854        |
+| 0.0563 | 53   | 0.1587        |
+| 0.0573 | 54   | 0.1555        |
+| 0.0584 | 55   | 0.1563        |
+| 0.0594 | 56   | 0.1711        |
+| 0.0605 | 57   | 0.1432        |
+| 0.0616 | 58   | 0.1263        |
+| 0.0626 | 59   | 0.1247        |
+| 0.0637 | 60   | 0.1369        |
+| 0.0648 | 61   | 0.1305        |
+| 0.0658 | 62   | 0.1022        |
+| 0.0669 | 63   | 0.1191        |
+| 0.0679 | 64   | 0.1083        |
+| 0.0690 | 65   | 0.0936        |
+| 0.0701 | 66   | 0.0988        |
+| 0.0711 | 67   | 0.0942        |
+| 0.0722 | 68   | 0.107         |
+| 0.0732 | 69   | 0.0823        |
+| 0.0743 | 70   | 0.0886        |
+| 0.0754 | 71   | 0.1055        |
+| 0.0764 | 72   | 0.1013        |
+| 0.0775 | 73   | 0.0807        |
+| 0.0786 | 74   | 0.0776        |
+| 0.0796 | 75   | 0.0737        |
+| 0.0807 | 76   | 0.0916        |
+| 0.0817 | 77   | 0.0654        |
+| 0.0828 | 78   | 0.0904        |
+| 0.0839 | 79   | 0.0954        |
+| 0.0849 | 80   | 0.0697        |
+| 0.0860 | 81   | 0.0751        |
+| 0.0870 | 82   | 0.0886        |
+| 0.0881 | 83   | 0.0752        |
+| 0.0892 | 84   | 0.0806        |
+| 0.0902 | 85   | 0.0807        |
+| 0.0913 | 86   | 0.0842        |
+| 0.0924 | 87   | 0.0821        |
+| 0.0934 | 88   | 0.0723        |
+| 0.0945 | 89   | 0.0797        |
+| 0.0955 | 90   | 0.0797        |
+| 0.0966 | 91   | 0.0832        |
+| 0.0977 | 92   | 0.0713        |
+| 0.0987 | 93   | 0.0681        |
+| 0.0998 | 94   | 0.0825        |
+| 0.1008 | 95   | 0.0838        |
+| 0.1019 | 96   | 0.0746        |
+| 0.1030 | 97   | 0.0792        |
+| 0.1040 | 98   | 0.0692        |
+| 0.1051 | 99   | 0.0705        |
+| 0.1062 | 100  | 0.0666        |
+| 0.1072 | 101  | 0.0692        |
+| 0.1083 | 102  | 0.0675        |
+| 0.1093 | 103  | 0.0734        |
+| 0.1104 | 104  | 0.072         |
+| 0.1115 | 105  | 0.0565        |
+| 0.1125 | 106  | 0.0663        |
+| 0.1136 | 107  | 0.0789        |
+| 0.1146 | 108  | 0.0605        |
+| 0.1157 | 109  | 0.0671        |
+| 0.1168 | 110  | 0.083         |
+| 0.1178 | 111  | 0.071         |
+| 0.1189 | 112  | 0.0759        |
+| 0.1200 | 113  | 0.0604        |
+| 0.1210 | 114  | 0.0682        |
+| 0.1221 | 115  | 0.0531        |
+| 0.1231 | 116  | 0.0779        |
+| 0.1242 | 117  | 0.0646        |
+| 0.1253 | 118  | 0.0621        |
+| 0.1263 | 119  | 0.081         |
+| 0.1274 | 120  | 0.0688        |
+| 0.1285 | 121  | 0.055         |
+| 0.1295 | 122  | 0.0513        |
+| 0.1306 | 123  | 0.063         |
+| 0.1316 | 124  | 0.0634        |
+| 0.1327 | 125  | 0.075         |
+| 0.1338 | 126  | 0.062         |
+| 0.1348 | 127  | 0.0821        |
+| 0.1359 | 128  | 0.0565        |
+| 0.1369 | 129  | 0.0492        |
+| 0.1380 | 130  | 0.0762        |
+| 0.1391 | 131  | 0.0735        |
+| 0.1401 | 132  | 0.069         |
+| 0.1412 | 133  | 0.0619        |
+| 0.1423 | 134  | 0.0789        |
+| 0.1433 | 135  | 0.0621        |
+| 0.1444 | 136  | 0.0568        |
+| 0.1454 | 137  | 0.0717        |
+| 0.1465 | 138  | 0.0764        |
+| 0.1476 | 139  | 0.0502        |
+| 0.1486 | 140  | 0.0626        |
+| 0.1497 | 141  | 0.0615        |
+| 0.1507 | 142  | 0.0555        |
+| 0.1518 | 143  | 0.0674        |
+| 0.1529 | 144  | 0.0635        |
+| 0.1539 | 145  | 0.0553        |
+| 0.1550 | 146  | 0.0525        |
+| 0.1561 | 147  | 0.055         |
+| 0.1571 | 148  | 0.0665        |
+| 0.1582 | 149  | 0.0703        |
+| 0.1592 | 150  | 0.0657        |
+| 0.1603 | 151  | 0.0612        |
+| 0.1614 | 152  | 0.0671        |
+| 0.1624 | 153  | 0.059         |
+| 0.1635 | 154  | 0.0636        |
+| 0.1645 | 155  | 0.0753        |
+| 0.1656 | 156  | 0.0931        |
+| 0.1667 | 157  | 0.0531        |
+| 0.1677 | 158  | 0.0558        |
+| 0.1688 | 159  | 0.0599        |
+| 0.1699 | 160  | 0.0501        |
+| 0.1709 | 161  | 0.051         |
+| 0.1720 | 162  | 0.0697        |
+| 0.1730 | 163  | 0.074         |
+| 0.1741 | 164  | 0.0607        |
+| 0.1752 | 165  | 0.0611        |
+| 0.1762 | 166  | 0.059         |
+| 0.1773 | 167  | 0.073         |
+| 0.1783 | 168  | 0.0541        |
+| 0.1794 | 169  | 0.0576        |
+| 0.1805 | 170  | 0.0656        |
+| 0.1815 | 171  | 0.0499        |
+| 0.1826 | 172  | 0.055         |
+| 0.1837 | 173  | 0.0646        |
+| 0.1847 | 174  | 0.0747        |
+| 0.1858 | 175  | 0.0558        |
+| 0.1868 | 176  | 0.0537        |
+| 0.1879 | 177  | 0.0574        |
+| 0.1890 | 178  | 0.061         |
+| 0.1900 | 179  | 0.0743        |
+| 0.1911 | 180  | 0.0553        |
+| 0.1921 | 181  | 0.0603        |
+| 0.1932 | 182  | 0.0613        |
+| 0.1943 | 183  | 0.0557        |
+| 0.1953 | 184  | 0.0629        |
+| 0.1964 | 185  | 0.0524        |
+| 0.1975 | 186  | 0.0533        |
+| 0.1985 | 187  | 0.0624        |
+| 0.1996 | 188  | 0.0566        |
+| 0.2006 | 189  | 0.0446        |
+| 0.2017 | 190  | 0.0578        |
+| 0.2028 | 191  | 0.0487        |
+| 0.2038 | 192  | 0.066         |
+| 0.2049 | 193  | 0.0618        |
+| 0.2059 | 194  | 0.0591        |
+| 0.2070 | 195  | 0.0553        |
+| 0.2081 | 196  | 0.052         |
+| 0.2091 | 197  | 0.0451        |
+| 0.2102 | 198  | 0.0633        |
+| 0.2113 | 199  | 0.0658        |
+| 0.2123 | 200  | 0.0623        |
+| 0.2134 | 201  | 0.0593        |
+| 0.2144 | 202  | 0.0491        |
+| 0.2155 | 203  | 0.0526        |
+| 0.2166 | 204  | 0.057         |
+| 0.2176 | 205  | 0.0631        |
+| 0.2187 | 206  | 0.0809        |
+| 0.2197 | 207  | 0.063         |
+| 0.2208 | 208  | 0.0571        |
+| 0.2219 | 209  | 0.054         |
+| 0.2229 | 210  | 0.0607        |
+| 0.2240 | 211  | 0.056         |
+| 0.2251 | 212  | 0.06          |
+| 0.2261 | 213  | 0.0597        |
+| 0.2272 | 214  | 0.0538        |
+| 0.2282 | 215  | 0.0584        |
+| 0.2293 | 216  | 0.0473        |
+| 0.2304 | 217  | 0.052         |
+| 0.2314 | 218  | 0.06          |
+| 0.2325 | 219  | 0.0566        |
+| 0.2335 | 220  | 0.0559        |
+| 0.2346 | 221  | 0.0536        |
+| 0.2357 | 222  | 0.0634        |
+| 0.2367 | 223  | 0.0637        |
+| 0.2378 | 224  | 0.056         |
+| 0.2389 | 225  | 0.0504        |
+| 0.2399 | 226  | 0.0371        |
+| 0.2410 | 227  | 0.0678        |
+| 0.2420 | 228  | 0.0569        |
+| 0.2431 | 229  | 0.0551        |
+| 0.2442 | 230  | 0.0486        |
+| 0.2452 | 231  | 0.0536        |
+| 0.2463 | 232  | 0.0615        |
+| 0.2473 | 233  | 0.0535        |
+| 0.2484 | 234  | 0.0502        |
+| 0.2495 | 235  | 0.0571        |
+| 0.2505 | 236  | 0.0593        |
+| 0.2516 | 237  | 0.0557        |
+| 0.2527 | 238  | 0.0671        |
+| 0.2537 | 239  | 0.0609        |
+| 0.2548 | 240  | 0.0667        |
+| 0.2558 | 241  | 0.064         |
+| 0.2569 | 242  | 0.0503        |
+| 0.2580 | 243  | 0.0461        |
+| 0.2590 | 244  | 0.059         |
+| 0.2601 | 245  | 0.0594        |
+| 0.2611 | 246  | 0.0577        |
+| 0.2622 | 247  | 0.0664        |
+| 0.2633 | 248  | 0.0736        |
+| 0.2643 | 249  | 0.0506        |
+| 0.2654 | 250  | 0.0611        |
+| 0.2665 | 251  | 0.0657        |
+| 0.2675 | 252  | 0.0543        |
+| 0.2686 | 253  | 0.0595        |
+| 0.2696 | 254  | 0.0531        |
+| 0.2707 | 255  | 0.0552        |
+| 0.2718 | 256  | 0.061         |
+| 0.2728 | 257  | 0.0456        |
+| 0.2739 | 258  | 0.0498        |
+| 0.2749 | 259  | 0.0567        |
+| 0.2760 | 260  | 0.0444        |
+| 0.2771 | 261  | 0.0567        |
+| 0.2781 | 262  | 0.0524        |
+| 0.2792 | 263  | 0.0518        |
+| 0.2803 | 264  | 0.0664        |
+| 0.2813 | 265  | 0.0537        |
+| 0.2824 | 266  | 0.0537        |
+| 0.2834 | 267  | 0.0558        |
+| 0.2845 | 268  | 0.0501        |
+| 0.2856 | 269  | 0.0558        |
+| 0.2866 | 270  | 0.0411        |
+| 0.2877 | 271  | 0.0432        |
+| 0.2887 | 272  | 0.0535        |
+| 0.2898 | 273  | 0.0511        |
+| 0.2909 | 274  | 0.0469        |
+| 0.2919 | 275  | 0.0587        |
+| 0.2930 | 276  | 0.052         |
+| 0.2941 | 277  | 0.0594        |
+| 0.2951 | 278  | 0.0651        |
+| 0.2962 | 279  | 0.0486        |
+| 0.2972 | 280  | 0.0602        |
+| 0.2983 | 281  | 0.0567        |
+| 0.2994 | 282  | 0.0547        |
+| 0.3004 | 283  | 0.0669        |
+| 0.3015 | 284  | 0.0543        |
+| 0.3025 | 285  | 0.0616        |
+| 0.3036 | 286  | 0.0532        |
+| 0.3047 | 287  | 0.0689        |
+| 0.3057 | 288  | 0.0461        |
+| 0.3068 | 289  | 0.0516        |
+| 0.3079 | 290  | 0.0496        |
+| 0.3089 | 291  | 0.0581        |
+| 0.3100 | 292  | 0.0446        |
+| 0.3110 | 293  | 0.048         |
+| 0.3121 | 294  | 0.0442        |
+| 0.3132 | 295  | 0.0504        |
+| 0.3142 | 296  | 0.0531        |
+| 0.3153 | 297  | 0.0681        |
+| 0.3163 | 298  | 0.0458        |
+| 0.3174 | 299  | 0.0584        |
+| 0.3185 | 300  | 0.064         |
+| 0.3195 | 301  | 0.0595        |
+| 0.3206 | 302  | 0.0604        |
+| 0.3217 | 303  | 0.0621        |
+| 0.3227 | 304  | 0.0466        |
+| 0.3238 | 305  | 0.0545        |
+| 0.3248 | 306  | 0.0523        |
+| 0.3259 | 307  | 0.0496        |
+| 0.3270 | 308  | 0.0468        |
+| 0.3280 | 309  | 0.0649        |
+| 0.3291 | 310  | 0.056         |
+| 0.3301 | 311  | 0.0539        |
+| 0.3312 | 312  | 0.0497        |
+| 0.3323 | 313  | 0.0517        |
+| 0.3333 | 314  | 0.0511        |
+| 0.3344 | 315  | 0.0511        |
+| 0.3355 | 316  | 0.0518        |
+| 0.3365 | 317  | 0.0508        |
+| 0.3376 | 318  | 0.0579        |
+| 0.3386 | 319  | 0.0463        |
+| 0.3397 | 320  | 0.046         |
+| 0.3408 | 321  | 0.0461        |
+| 0.3418 | 322  | 0.0469        |
+| 0.3429 | 323  | 0.0399        |
+| 0.3439 | 324  | 0.0516        |
+| 0.3450 | 325  | 0.0551        |
+| 0.3461 | 326  | 0.0497        |
+| 0.3471 | 327  | 0.0455        |
+| 0.3482 | 328  | 0.0534        |
+| 0.3493 | 329  | 0.0437        |
+| 0.3503 | 330  | 0.0542        |
+| 0.3514 | 331  | 0.0462        |
+| 0.3524 | 332  | 0.0429        |
+| 0.3535 | 333  | 0.0542        |
+| 0.3546 | 334  | 0.0452        |
+| 0.3556 | 335  | 0.0569        |
+| 0.3567 | 336  | 0.0495        |
+| 0.3577 | 337  | 0.0443        |
+| 0.3588 | 338  | 0.0543        |
+| 0.3599 | 339  | 0.0671        |
+| 0.3609 | 340  | 0.054         |
+| 0.3620 | 341  | 0.0596        |
+| 0.3631 | 342  | 0.0468        |
+| 0.3641 | 343  | 0.0644        |
+| 0.3652 | 344  | 0.044         |
+| 0.3662 | 345  | 0.0477        |
+| 0.3673 | 346  | 0.0403        |
+| 0.3684 | 347  | 0.0553        |
+| 0.3694 | 348  | 0.0533        |
+| 0.3705 | 349  | 0.0447        |
+| 0.3715 | 350  | 0.0527        |
+| 0.3726 | 351  | 0.0465        |
+| 0.3737 | 352  | 0.0518        |
+| 0.3747 | 353  | 0.0345        |
+| 0.3758 | 354  | 0.0515        |
+| 0.3769 | 355  | 0.0438        |
+| 0.3779 | 356  | 0.0489        |
+| 0.3790 | 357  | 0.046         |
+| 0.3800 | 358  | 0.0621        |
+| 0.3811 | 359  | 0.0667        |
+| 0.3822 | 360  | 0.0489        |
+| 0.3832 | 361  | 0.0555        |
+| 0.3843 | 362  | 0.0445        |
+| 0.3854 | 363  | 0.0492        |
+| 0.3864 | 364  | 0.0562        |
+| 0.3875 | 365  | 0.0484        |
+| 0.3885 | 366  | 0.0582        |
+| 0.3896 | 367  | 0.0551        |
+| 0.3907 | 368  | 0.0512        |
+| 0.3917 | 369  | 0.0486        |
+| 0.3928 | 370  | 0.0537        |
+| 0.3938 | 371  | 0.0499        |
+| 0.3949 | 372  | 0.0651        |
+| 0.3960 | 373  | 0.0531        |
+| 0.3970 | 374  | 0.0743        |
+| 0.3981 | 375  | 0.052         |
+| 0.3992 | 376  | 0.0476        |
+| 0.4002 | 377  | 0.0572        |
+| 0.4013 | 378  | 0.0555        |
+| 0.4023 | 379  | 0.0569        |
+| 0.4034 | 380  | 0.052         |
+| 0.4045 | 381  | 0.0524        |
+| 0.4055 | 382  | 0.0726        |
+| 0.4066 | 383  | 0.0456        |
+| 0.4076 | 384  | 0.0531        |
+| 0.4087 | 385  | 0.0474        |
+| 0.4098 | 386  | 0.0485        |
+| 0.4108 | 387  | 0.0459        |
+| 0.4119 | 388  | 0.0474        |
+| 0.4130 | 389  | 0.0541        |
+| 0.4140 | 390  | 0.0452        |
+| 0.4151 | 391  | 0.0362        |
+| 0.4161 | 392  | 0.0407        |
+| 0.4172 | 393  | 0.0449        |
+| 0.4183 | 394  | 0.0444        |
+| 0.4193 | 395  | 0.0469        |
+| 0.4204 | 396  | 0.0493        |
+| 0.4214 | 397  | 0.0437        |
+| 0.4225 | 398  | 0.0551        |
+| 0.4236 | 399  | 0.0412        |
+| 0.4246 | 400  | 0.0401        |
+| 0.4257 | 401  | 0.0488        |
+| 0.4268 | 402  | 0.0506        |
+| 0.4278 | 403  | 0.0458        |
+| 0.4289 | 404  | 0.0436        |
+| 0.4299 | 405  | 0.0574        |
+| 0.4310 | 406  | 0.0516        |
+| 0.4321 | 407  | 0.0599        |
+| 0.4331 | 408  | 0.0476        |
+| 0.4342 | 409  | 0.0462        |
+| 0.4352 | 410  | 0.0502        |
+| 0.4363 | 411  | 0.0448        |
+| 0.4374 | 412  | 0.0461        |
+| 0.4384 | 413  | 0.035         |
+| 0.4395 | 414  | 0.0451        |
+| 0.4406 | 415  | 0.0456        |
+| 0.4416 | 416  | 0.0399        |
+| 0.4427 | 417  | 0.0602        |
+| 0.4437 | 418  | 0.0588        |
+| 0.4448 | 419  | 0.0675        |
+| 0.4459 | 420  | 0.0628        |
+| 0.4469 | 421  | 0.0498        |
+| 0.4480 | 422  | 0.0413        |
+| 0.4490 | 423  | 0.0437        |
+| 0.4501 | 424  | 0.0514        |
+| 0.4512 | 425  | 0.0586        |
+| 0.4522 | 426  | 0.0596        |
+| 0.4533 | 427  | 0.0368        |
+| 0.4544 | 428  | 0.0448        |
+| 0.4554 | 429  | 0.056         |
+| 0.4565 | 430  | 0.0415        |
+| 0.4575 | 431  | 0.0448        |
+| 0.4586 | 432  | 0.055         |
+| 0.4597 | 433  | 0.0442        |
+| 0.4607 | 434  | 0.0462        |
+| 0.4618 | 435  | 0.0479        |
+| 0.4628 | 436  | 0.0507        |
+| 0.4639 | 437  | 0.049         |
+| 0.4650 | 438  | 0.0626        |
+| 0.4660 | 439  | 0.0375        |
+| 0.4671 | 440  | 0.0541        |
+| 0.4682 | 441  | 0.0579        |
+| 0.4692 | 442  | 0.0642        |
+| 0.4703 | 443  | 0.0471        |
+| 0.4713 | 444  | 0.0559        |
+| 0.4724 | 445  | 0.0508        |
+| 0.4735 | 446  | 0.0696        |
+| 0.4745 | 447  | 0.056         |
+| 0.4756 | 448  | 0.0649        |
+| 0.4766 | 449  | 0.0641        |
+| 0.4777 | 450  | 0.0547        |
+| 0.4788 | 451  | 0.0509        |
+| 0.4798 | 452  | 0.0544        |
+| 0.4809 | 453  | 0.0487        |
+| 0.4820 | 454  | 0.0639        |
+| 0.4830 | 455  | 0.047         |
+| 0.4841 | 456  | 0.0513        |
+| 0.4851 | 457  | 0.0451        |
+| 0.4862 | 458  | 0.0567        |
+| 0.4873 | 459  | 0.0541        |
+| 0.4883 | 460  | 0.0475        |
+| 0.4894 | 461  | 0.0445        |
+| 0.4904 | 462  | 0.0597        |
+| 0.4915 | 463  | 0.0434        |
+| 0.4926 | 464  | 0.0468        |
+| 0.4936 | 465  | 0.0449        |
+| 0.4947 | 466  | 0.0422        |
+| 0.4958 | 467  | 0.0504        |
+| 0.4968 | 468  | 0.0565        |
+| 0.4979 | 469  | 0.0611        |
+| 0.4989 | 470  | 0.044         |
+| 0.5    | 471  | 0.0543        |
+| 0.5011 | 472  | 0.0424        |
+| 0.5021 | 473  | 0.0443        |
+| 0.5032 | 474  | 0.0367        |
+| 0.5042 | 475  | 0.0427        |
+| 0.5053 | 476  | 0.0431        |
+| 0.5064 | 477  | 0.063         |
+| 0.5074 | 478  | 0.0421        |
+| 0.5085 | 479  | 0.0367        |
+| 0.5096 | 480  | 0.0456        |
+| 0.5106 | 481  | 0.0586        |
+| 0.5117 | 482  | 0.0747        |
+| 0.5127 | 483  | 0.05          |
+| 0.5138 | 484  | 0.0509        |
+| 0.5149 | 485  | 0.054         |
+| 0.5159 | 486  | 0.0531        |
+| 0.5170 | 487  | 0.0458        |
+| 0.5180 | 488  | 0.0522        |
+| 0.5191 | 489  | 0.0406        |
+| 0.5202 | 490  | 0.0529        |
+| 0.5212 | 491  | 0.0602        |
+| 0.5223 | 492  | 0.0469        |
+| 0.5234 | 493  | 0.0602        |
+| 0.5244 | 494  | 0.0506        |
+| 0.5255 | 495  | 0.0522        |
+| 0.5265 | 496  | 0.0433        |
+| 0.5276 | 497  | 0.0531        |
+| 0.5287 | 498  | 0.0453        |
+| 0.5297 | 499  | 0.0416        |
+| 0.5308 | 500  | 0.0366        |
+| 0.5318 | 501  | 0.0483        |
+| 0.5329 | 502  | 0.0453        |
+| 0.5340 | 503  | 0.0495        |
+| 0.5350 | 504  | 0.0522        |
+| 0.5361 | 505  | 0.0476        |
+| 0.5372 | 506  | 0.0416        |
+| 0.5382 | 507  | 0.0497        |
+| 0.5393 | 508  | 0.0431        |
+| 0.5403 | 509  | 0.0494        |
+| 0.5414 | 510  | 0.041         |
+| 0.5425 | 511  | 0.0412        |
+| 0.5435 | 512  | 0.0399        |
+| 0.5446 | 513  | 0.0478        |
+| 0.5456 | 514  | 0.061         |
+| 0.5467 | 515  | 0.0353        |
+| 0.5478 | 516  | 0.0469        |
+| 0.5488 | 517  | 0.0517        |
+| 0.5499 | 518  | 0.0523        |
+| 0.5510 | 519  | 0.058         |
+| 0.5520 | 520  | 0.0432        |
+| 0.5531 | 521  | 0.0442        |
+| 0.5541 | 522  | 0.0551        |
+| 0.5552 | 523  | 0.0488        |
+| 0.5563 | 524  | 0.0482        |
+| 0.5573 | 525  | 0.0474        |
+| 0.5584 | 526  | 0.0577        |
+| 0.5594 | 527  | 0.0375        |
+| 0.5605 | 528  | 0.0401        |
+| 0.5616 | 529  | 0.0574        |
+| 0.5626 | 530  | 0.0496        |
+| 0.5637 | 531  | 0.0422        |
+| 0.5648 | 532  | 0.047         |
+| 0.5658 | 533  | 0.0455        |
+| 0.5669 | 534  | 0.0405        |
+| 0.5679 | 535  | 0.0391        |
+| 0.5690 | 536  | 0.0495        |
+| 0.5701 | 537  | 0.0464        |
+| 0.5711 | 538  | 0.0457        |
+| 0.5722 | 539  | 0.0449        |
+| 0.5732 | 540  | 0.0583        |
+| 0.5743 | 541  | 0.0591        |
+| 0.5754 | 542  | 0.0487        |
+| 0.5764 | 543  | 0.0456        |
+| 0.5775 | 544  | 0.0423        |
+| 0.5786 | 545  | 0.0571        |
+| 0.5796 | 546  | 0.0472        |
+| 0.5807 | 547  | 0.0556        |
+| 0.5817 | 548  | 0.0483        |
+| 0.5828 | 549  | 0.0424        |
+| 0.5839 | 550  | 0.0557        |
+| 0.5849 | 551  | 0.038         |
+| 0.5860 | 552  | 0.0394        |
+| 0.5870 | 553  | 0.0481        |
+| 0.5881 | 554  | 0.0617        |
+| 0.5892 | 555  | 0.0455        |
+| 0.5902 | 556  | 0.0411        |
+| 0.5913 | 557  | 0.0433        |
+| 0.5924 | 558  | 0.0456        |
+| 0.5934 | 559  | 0.0488        |
+| 0.5945 | 560  | 0.0517        |
+| 0.5955 | 561  | 0.0549        |
+| 0.5966 | 562  | 0.0406        |
+| 0.5977 | 563  | 0.045         |
+| 0.5987 | 564  | 0.049         |
+| 0.5998 | 565  | 0.0547        |
+| 0.6008 | 566  | 0.0529        |
+| 0.6019 | 567  | 0.0524        |
+| 0.6030 | 568  | 0.0472        |
+| 0.6040 | 569  | 0.039         |
+| 0.6051 | 570  | 0.041         |
+| 0.6062 | 571  | 0.0508        |
+| 0.6072 | 572  | 0.0486        |
+| 0.6083 | 573  | 0.0375        |
+| 0.6093 | 574  | 0.0585        |
+| 0.6104 | 575  | 0.05          |
+| 0.6115 | 576  | 0.0509        |
+| 0.6125 | 577  | 0.0394        |
+| 0.6136 | 578  | 0.0467        |
+| 0.6146 | 579  | 0.0371        |
+| 0.6157 | 580  | 0.0415        |
+| 0.6168 | 581  | 0.046         |
+| 0.6178 | 582  | 0.0385        |
+| 0.6189 | 583  | 0.056         |
+| 0.6200 | 584  | 0.0416        |
+| 0.6210 | 585  | 0.0578        |
+| 0.6221 | 586  | 0.0443        |
+| 0.6231 | 587  | 0.0407        |
+| 0.6242 | 588  | 0.0499        |
+| 0.6253 | 589  | 0.056         |
+| 0.6263 | 590  | 0.0456        |
+| 0.6274 | 591  | 0.0412        |
+| 0.6285 | 592  | 0.0473        |
+| 0.6295 | 593  | 0.0378        |
+| 0.6306 | 594  | 0.0544        |
+| 0.6316 | 595  | 0.0502        |
+| 0.6327 | 596  | 0.042         |
+| 0.6338 | 597  | 0.0414        |
+| 0.6348 | 598  | 0.0506        |
+| 0.6359 | 599  | 0.0372        |
+| 0.6369 | 600  | 0.0411        |
+| 0.6380 | 601  | 0.0387        |
+| 0.6391 | 602  | 0.0588        |
+| 0.6401 | 603  | 0.0404        |
+| 0.6412 | 604  | 0.056         |
+| 0.6423 | 605  | 0.0524        |
+| 0.6433 | 606  | 0.0484        |
+| 0.6444 | 607  | 0.0398        |
+| 0.6454 | 608  | 0.0523        |
+| 0.6465 | 609  | 0.0469        |
+| 0.6476 | 610  | 0.0504        |
+| 0.6486 | 611  | 0.0496        |
+| 0.6497 | 612  | 0.0501        |
+| 0.6507 | 613  | 0.0426        |
+| 0.6518 | 614  | 0.0454        |
+| 0.6529 | 615  | 0.0564        |
+| 0.6539 | 616  | 0.0798        |
+| 0.6550 | 617  | 0.0444        |
+| 0.6561 | 618  | 0.039         |
+| 0.6571 | 619  | 0.0428        |
+| 0.6582 | 620  | 0.0504        |
+| 0.6592 | 621  | 0.0525        |
+| 0.6603 | 622  | 0.0471        |
+| 0.6614 | 623  | 0.0402        |
+| 0.6624 | 624  | 0.0456        |
+| 0.6635 | 625  | 0.0384        |
+| 0.6645 | 626  | 0.0446        |
+| 0.6656 | 627  | 0.0468        |
+| 0.6667 | 628  | 0.047         |
+| 0.6677 | 629  | 0.0442        |
+| 0.6688 | 630  | 0.0466        |
+| 0.6699 | 631  | 0.0457        |
+| 0.6709 | 632  | 0.0538        |
+| 0.6720 | 633  | 0.0434        |
+| 0.6730 | 634  | 0.0443        |
+| 0.6741 | 635  | 0.0481        |
+| 0.6752 | 636  | 0.0483        |
+| 0.6762 | 637  | 0.0434        |
+| 0.6773 | 638  | 0.0389        |
+| 0.6783 | 639  | 0.0541        |
+| 0.6794 | 640  | 0.0453        |
+| 0.6805 | 641  | 0.0508        |
+| 0.6815 | 642  | 0.0469        |
+| 0.6826 | 643  | 0.0431        |
+| 0.6837 | 644  | 0.0446        |
+| 0.6847 | 645  | 0.0427        |
+| 0.6858 | 646  | 0.0543        |
+| 0.6868 | 647  | 0.0458        |
+| 0.6879 | 648  | 0.046         |
+| 0.6890 | 649  | 0.0669        |
+| 0.6900 | 650  | 0.046         |
+| 0.6911 | 651  | 0.0462        |
+| 0.6921 | 652  | 0.0493        |
+| 0.6932 | 653  | 0.0484        |
+| 0.6943 | 654  | 0.0466        |
+| 0.6953 | 655  | 0.048         |
+| 0.6964 | 656  | 0.0406        |
+| 0.6975 | 657  | 0.0512        |
+| 0.6985 | 658  | 0.0469        |
+| 0.6996 | 659  | 0.0461        |
+| 0.7006 | 660  | 0.039         |
+| 0.7017 | 661  | 0.0403        |
+| 0.7028 | 662  | 0.0419        |
+| 0.7038 | 663  | 0.0538        |
+| 0.7049 | 664  | 0.0364        |
+| 0.7059 | 665  | 0.039         |
+| 0.7070 | 666  | 0.0417        |
+| 0.7081 | 667  | 0.0478        |
+| 0.7091 | 668  | 0.0443        |
+| 0.7102 | 669  | 0.0394        |
+| 0.7113 | 670  | 0.0417        |
+| 0.7123 | 671  | 0.0412        |
+| 0.7134 | 672  | 0.0493        |
+| 0.7144 | 673  | 0.0532        |
+| 0.7155 | 674  | 0.0371        |
+| 0.7166 | 675  | 0.0344        |
+| 0.7176 | 676  | 0.0421        |
+| 0.7187 | 677  | 0.0489        |
+| 0.7197 | 678  | 0.0362        |
+| 0.7208 | 679  | 0.0539        |
+| 0.7219 | 680  | 0.0404        |
+| 0.7229 | 681  | 0.0607        |
+| 0.7240 | 682  | 0.0456        |
+| 0.7251 | 683  | 0.0507        |
+| 0.7261 | 684  | 0.0415        |
+| 0.7272 | 685  | 0.0361        |
+| 0.7282 | 686  | 0.053         |
+| 0.7293 | 687  | 0.0431        |
+| 0.7304 | 688  | 0.0463        |
+| 0.7314 | 689  | 0.0401        |
+| 0.7325 | 690  | 0.0549        |
+| 0.7335 | 691  | 0.0335        |
+| 0.7346 | 692  | 0.05          |
+| 0.7357 | 693  | 0.0472        |
+| 0.7367 | 694  | 0.0474        |
+| 0.7378 | 695  | 0.0556        |
+| 0.7389 | 696  | 0.0456        |
+| 0.7399 | 697  | 0.0481        |
+| 0.7410 | 698  | 0.0388        |
+| 0.7420 | 699  | 0.0381        |
+| 0.7431 | 700  | 0.0491        |
+| 0.7442 | 701  | 0.0436        |
+| 0.7452 | 702  | 0.0522        |
+| 0.7463 | 703  | 0.0471        |
+| 0.7473 | 704  | 0.0367        |
+| 0.7484 | 705  | 0.0393        |
+| 0.7495 | 706  | 0.0418        |
+| 0.7505 | 707  | 0.0371        |
+| 0.7516 | 708  | 0.0315        |
+| 0.7527 | 709  | 0.0508        |
+| 0.7537 | 710  | 0.0535        |
+| 0.7548 | 711  | 0.0453        |
+| 0.7558 | 712  | 0.0352        |
+| 0.7569 | 713  | 0.0507        |
+| 0.7580 | 714  | 0.046         |
+| 0.7590 | 715  | 0.0393        |
+| 0.7601 | 716  | 0.0453        |
+| 0.7611 | 717  | 0.0403        |
+| 0.7622 | 718  | 0.0346        |
+| 0.7633 | 719  | 0.0492        |
+| 0.7643 | 720  | 0.0437        |
+| 0.7654 | 721  | 0.042         |
+| 0.7665 | 722  | 0.052         |
+| 0.7675 | 723  | 0.043         |
+| 0.7686 | 724  | 0.0524        |
+| 0.7696 | 725  | 0.0385        |
+| 0.7707 | 726  | 0.0484        |
+| 0.7718 | 727  | 0.0454        |
+| 0.7728 | 728  | 0.0478        |
+| 0.7739 | 729  | 0.0411        |
+| 0.7749 | 730  | 0.0415        |
+| 0.7760 | 731  | 0.0323        |
+| 0.7771 | 732  | 0.0492        |
+| 0.7781 | 733  | 0.0429        |
+| 0.7792 | 734  | 0.0445        |
+| 0.7803 | 735  | 0.0484        |
+| 0.7813 | 736  | 0.042         |
+| 0.7824 | 737  | 0.0486        |
+| 0.7834 | 738  | 0.0349        |
+| 0.7845 | 739  | 0.0472        |
+| 0.7856 | 740  | 0.0413        |
+| 0.7866 | 741  | 0.0476        |
+| 0.7877 | 742  | 0.0519        |
+| 0.7887 | 743  | 0.0405        |
+| 0.7898 | 744  | 0.0439        |
+| 0.7909 | 745  | 0.035         |
+| 0.7919 | 746  | 0.0478        |
+| 0.7930 | 747  | 0.0476        |
+| 0.7941 | 748  | 0.0382        |
+| 0.7951 | 749  | 0.0568        |
+| 0.7962 | 750  | 0.0505        |
+| 0.7972 | 751  | 0.0572        |
+| 0.7983 | 752  | 0.0352        |
+| 0.7994 | 753  | 0.0405        |
+| 0.8004 | 754  | 0.0505        |
+| 0.8015 | 755  | 0.0478        |
+| 0.8025 | 756  | 0.0465        |
+| 0.8036 | 757  | 0.0493        |
+| 0.8047 | 758  | 0.0414        |
+| 0.8057 | 759  | 0.0438        |
+| 0.8068 | 760  | 0.0559        |
+| 0.8079 | 761  | 0.044         |
+| 0.8089 | 762  | 0.0385        |
+| 0.8100 | 763  | 0.0414        |
+| 0.8110 | 764  | 0.0516        |
+| 0.8121 | 765  | 0.0475        |
+| 0.8132 | 766  | 0.0394        |
+| 0.8142 | 767  | 0.0566        |
+| 0.8153 | 768  | 0.0385        |
+| 0.8163 | 769  | 0.0405        |
+| 0.8174 | 770  | 0.0392        |
+| 0.8185 | 771  | 0.0364        |
+| 0.8195 | 772  | 0.0501        |
+| 0.8206 | 773  | 0.0462        |
+| 0.8217 | 774  | 0.0436        |
+| 0.8227 | 775  | 0.0548        |
+| 0.8238 | 776  | 0.0429        |
+| 0.8248 | 777  | 0.0416        |
+| 0.8259 | 778  | 0.043         |
+| 0.8270 | 779  | 0.0481        |
+| 0.8280 | 780  | 0.0382        |
+| 0.8291 | 781  | 0.0439        |
+| 0.8301 | 782  | 0.0369        |
+| 0.8312 | 783  | 0.0377        |
+| 0.8323 | 784  | 0.0463        |
+| 0.8333 | 785  | 0.0372        |
+| 0.8344 | 786  | 0.0563        |
+| 0.8355 | 787  | 0.0447        |
+| 0.8365 | 788  | 0.0366        |
+| 0.8376 | 789  | 0.0466        |
+| 0.8386 | 790  | 0.049         |
+| 0.8397 | 791  | 0.0557        |
+| 0.8408 | 792  | 0.0495        |
+| 0.8418 | 793  | 0.0359        |
+| 0.8429 | 794  | 0.0519        |
+| 0.8439 | 795  | 0.0538        |
+| 0.8450 | 796  | 0.0388        |
+| 0.8461 | 797  | 0.0431        |
+| 0.8471 | 798  | 0.0513        |
+| 0.8482 | 799  | 0.047         |
+| 0.8493 | 800  | 0.0485        |
+| 0.8503 | 801  | 0.052         |
+| 0.8514 | 802  | 0.032         |
+| 0.8524 | 803  | 0.0419        |
+| 0.8535 | 804  | 0.0439        |
+| 0.8546 | 805  | 0.0548        |
+| 0.8556 | 806  | 0.0433        |
+| 0.8567 | 807  | 0.0407        |
+| 0.8577 | 808  | 0.0467        |
+| 0.8588 | 809  | 0.0494        |
+| 0.8599 | 810  | 0.0516        |
+| 0.8609 | 811  | 0.0418        |
+| 0.8620 | 812  | 0.0344        |
+| 0.8631 | 813  | 0.0505        |
+| 0.8641 | 814  | 0.0477        |
+| 0.8652 | 815  | 0.0533        |
+| 0.8662 | 816  | 0.0431        |
+| 0.8673 | 817  | 0.0439        |
+| 0.8684 | 818  | 0.0321        |
+| 0.8694 | 819  | 0.0418        |
+| 0.8705 | 820  | 0.043         |
+| 0.8715 | 821  | 0.035         |
+| 0.8726 | 822  | 0.0473        |
+| 0.8737 | 823  | 0.0294        |
+| 0.8747 | 824  | 0.0573        |
+| 0.8758 | 825  | 0.038         |
+| 0.8769 | 826  | 0.04          |
+| 0.8779 | 827  | 0.0406        |
+| 0.8790 | 828  | 0.0413        |
+| 0.8800 | 829  | 0.0416        |
+| 0.8811 | 830  | 0.0344        |
+| 0.8822 | 831  | 0.0511        |
+| 0.8832 | 832  | 0.0403        |
+| 0.8843 | 833  | 0.0613        |
+| 0.8854 | 834  | 0.0384        |
+| 0.8864 | 835  | 0.0363        |
+| 0.8875 | 836  | 0.0324        |
+| 0.8885 | 837  | 0.0472        |
+| 0.8896 | 838  | 0.049         |
+| 0.8907 | 839  | 0.0465        |
+| 0.8917 | 840  | 0.0419        |
+| 0.8928 | 841  | 0.0455        |
+| 0.8938 | 842  | 0.0481        |
+| 0.8949 | 843  | 0.0463        |
+| 0.8960 | 844  | 0.0352        |
+| 0.8970 | 845  | 0.0527        |
+| 0.8981 | 846  | 0.0561        |
+| 0.8992 | 847  | 0.0381        |
+| 0.9002 | 848  | 0.0434        |
+| 0.9013 | 849  | 0.0436        |
+| 0.9023 | 850  | 0.0462        |
+| 0.9034 | 851  | 0.0503        |
+| 0.9045 | 852  | 0.0479        |
+| 0.9055 | 853  | 0.0451        |
+| 0.9066 | 854  | 0.0459        |
+| 0.9076 | 855  | 0.0508        |
+| 0.9087 | 856  | 0.0453        |
+| 0.9098 | 857  | 0.0444        |
+| 0.9108 | 858  | 0.0461        |
+| 0.9119 | 859  | 0.056         |
+| 0.9130 | 860  | 0.0449        |
+| 0.9140 | 861  | 0.0477        |
+| 0.9151 | 862  | 0.0422        |
+| 0.9161 | 863  | 0.0481        |
+| 0.9172 | 864  | 0.0508        |
+| 0.9183 | 865  | 0.037         |
+| 0.9193 | 866  | 0.0491        |
+| 0.9204 | 867  | 0.0627        |
+| 0.9214 | 868  | 0.0432        |
+| 0.9225 | 869  | 0.0377        |
+| 0.9236 | 870  | 0.0448        |
+| 0.9246 | 871  | 0.0366        |
+| 0.9257 | 872  | 0.0406        |
+| 0.9268 | 873  | 0.0445        |
+| 0.9278 | 874  | 0.0424        |
+| 0.9289 | 875  | 0.0322        |
+| 0.9299 | 876  | 0.0441        |
+| 0.9310 | 877  | 0.0498        |
+| 0.9321 | 878  | 0.0418        |
+| 0.9331 | 879  | 0.0524        |
+| 0.9342 | 880  | 0.06          |
+| 0.9352 | 881  | 0.0428        |
+| 0.9363 | 882  | 0.0428        |
+| 0.9374 | 883  | 0.0509        |
+| 0.9384 | 884  | 0.0428        |
+| 0.9395 | 885  | 0.0295        |
+| 0.9406 | 886  | 0.0535        |
+| 0.9416 | 887  | 0.04          |
+| 0.9427 | 888  | 0.0425        |
+| 0.9437 | 889  | 0.0583        |
+| 0.9448 | 890  | 0.0374        |
+| 0.9459 | 891  | 0.0489        |
+| 0.9469 | 892  | 0.0472        |
+| 0.9480 | 893  | 0.0449        |
+| 0.9490 | 894  | 0.0342        |
+| 0.9501 | 895  | 0.0604        |
+| 0.9512 | 896  | 0.047         |
+| 0.9522 | 897  | 0.0433        |
+| 0.9533 | 898  | 0.0355        |
+| 0.9544 | 899  | 0.0419        |
+| 0.9554 | 900  | 0.044         |
+| 0.9565 | 901  | 0.0457        |
+| 0.9575 | 902  | 0.0377        |
+| 0.9586 | 903  | 0.0416        |
+| 0.9597 | 904  | 0.0505        |
+| 0.9607 | 905  | 0.0487        |
+| 0.9618 | 906  | 0.0473        |
+| 0.9628 | 907  | 0.0521        |
+| 0.9639 | 908  | 0.0336        |
+| 0.9650 | 909  | 0.0446        |
+| 0.9660 | 910  | 0.0423        |
+| 0.9671 | 911  | 0.0442        |
+| 0.9682 | 912  | 0.0505        |
+| 0.9692 | 913  | 0.0488        |
+| 0.9703 | 914  | 0.0367        |
+| 0.9713 | 915  | 0.0382        |
+| 0.9724 | 916  | 0.0487        |
+| 0.9735 | 917  | 0.061         |
+| 0.9745 | 918  | 0.0461        |
+| 0.9756 | 919  | 0.0377        |
+| 0.9766 | 920  | 0.0398        |
+| 0.9777 | 921  | 0.0363        |
+| 0.9788 | 922  | 0.0375        |
+| 0.9798 | 923  | 0.0503        |
+| 0.9809 | 924  | 0.0493        |
+| 0.9820 | 925  | 0.04          |
+| 0.9830 | 926  | 0.0379        |
+| 0.9841 | 927  | 0.0422        |
+| 0.9851 | 928  | 0.0517        |
+| 0.9862 | 929  | 0.0488        |
+| 0.9873 | 930  | 0.057         |
+| 0.9883 | 931  | 0.0388        |
+| 0.9894 | 932  | 0.0374        |
+| 0.9904 | 933  | 0.0374        |
+| 0.9915 | 934  | 0.0504        |
+| 0.9926 | 935  | 0.056         |
+| 0.9936 | 936  | 0.0478        |
+| 0.9947 | 937  | 0.0286        |
+| 0.9958 | 938  | 0.0415        |
+| 0.9968 | 939  | 0.037         |
+| 0.9979 | 940  | 0.0445        |
+| 0.9989 | 941  | 0.0451        |
+| 1.0    | 942  | 0.036         |
+| 1.0011 | 943  | 0.0346        |
+| 1.0021 | 944  | 0.044         |
+| 1.0032 | 945  | 0.044         |
+| 1.0042 | 946  | 0.0487        |
+| 1.0053 | 947  | 0.0411        |
+| 1.0064 | 948  | 0.0385        |
+| 1.0074 | 949  | 0.0414        |
+| 1.0085 | 950  | 0.0369        |
+| 1.0096 | 951  | 0.0381        |
+| 1.0106 | 952  | 0.0358        |
+| 1.0117 | 953  | 0.0455        |
+| 1.0127 | 954  | 0.0414        |
+| 1.0138 | 955  | 0.0327        |
+| 1.0149 | 956  | 0.0492        |
+| 1.0159 | 957  | 0.0552        |
+| 1.0170 | 958  | 0.0399        |
+| 1.0180 | 959  | 0.0442        |
+| 1.0191 | 960  | 0.0398        |
+| 1.0202 | 961  | 0.0418        |
+| 1.0212 | 962  | 0.037         |
+| 1.0223 | 963  | 0.0433        |
+| 1.0234 | 964  | 0.0405        |
+| 1.0244 | 965  | 0.0429        |
+| 1.0255 | 966  | 0.0364        |
+| 1.0265 | 967  | 0.0424        |
+| 1.0276 | 968  | 0.0419        |
+| 1.0287 | 969  | 0.044         |
+| 1.0297 | 970  | 0.0326        |
+| 1.0308 | 971  | 0.0391        |
+| 1.0318 | 972  | 0.0436        |
+| 1.0329 | 973  | 0.0466        |
+| 1.0340 | 974  | 0.0357        |
+| 1.0350 | 975  | 0.0562        |
+| 1.0361 | 976  | 0.0328        |
+| 1.0372 | 977  | 0.0423        |
+| 1.0382 | 978  | 0.0316        |
+| 1.0393 | 979  | 0.0488        |
+| 1.0403 | 980  | 0.0352        |
+| 1.0414 | 981  | 0.0383        |
+| 1.0425 | 982  | 0.0544        |
+| 1.0435 | 983  | 0.0336        |
+| 1.0446 | 984  | 0.0426        |
+| 1.0456 | 985  | 0.0301        |
+| 1.0467 | 986  | 0.048         |
+| 1.0478 | 987  | 0.0398        |
+| 1.0488 | 988  | 0.048         |
+| 1.0499 | 989  | 0.0451        |
+| 1.0510 | 990  | 0.0477        |
+| 1.0520 | 991  | 0.0437        |
+| 1.0531 | 992  | 0.0367        |
+| 1.0541 | 993  | 0.0438        |
+| 1.0552 | 994  | 0.0482        |
+| 1.0563 | 995  | 0.0445        |
+| 1.0573 | 996  | 0.0499        |
+| 1.0584 | 997  | 0.0409        |
+| 1.0594 | 998  | 0.0426        |
+| 1.0605 | 999  | 0.0417        |
+| 1.0616 | 1000 | 0.0498        |
+
+</details>
+
+### Framework Versions
+- Python: 3.10.12
+- Sentence Transformers: 3.2.1
+- Transformers: 4.44.2
+- PyTorch: 2.3.1+cu121
+- Accelerate: 1.1.1
+- Datasets: 2.21.0
+- Tokenizers: 0.19.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,50 @@
+{
+  "_name_or_path": "models/gte--noneg-v0-bs512-lr5e-5-epoch3/checkpoint-1000",
+  "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,
+  "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,
+  "torch_dtype": "float32",
+  "transformers_version": "4.44.2",
+  "type_vocab_size": 1,
+  "unpad_inputs": false,
+  "use_memory_efficient_attention": false,
+  "vocab_size": 250048
+}

config_sentence_transformers.json

@@ -0,0 +1,10 @@
+{
+  "__version__": {
+    "sentence_transformers": "3.2.1",
+    "transformers": "4.44.2",
+    "pytorch": "2.3.1+cu121"
+  },
+  "prompts": {},
+  "default_prompt_name": null,
+  "similarity_fn_name": null
+}

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:f6b638fc16f1ded763c1a016fa12f6fd100d8d940e4a26b7fc036ebec58229b7
+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"
+  }
+]

sentence_bert_config.json

@@ -0,0 +1,4 @@
+{
+  "max_seq_length": 512,
+  "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:883b037111086fd4dfebbbc9b7cee11e1517b5e0c0514879478661440f137085
+size 17082987

tokenizer_config.json

@@ -0,0 +1,61 @@
+{
+  "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>",
+  "mask_token": "<mask>",
+  "max_length": 512,
+  "model_max_length": 512,
+  "pad_to_multiple_of": null,
+  "pad_token": "<pad>",
+  "pad_token_type_id": 0,
+  "padding_side": "right",
+  "sep_token": "</s>",
+  "stride": 0,
+  "tokenizer_class": "XLMRobertaTokenizer",
+  "truncation_side": "right",
+  "truncation_strategy": "longest_first",
+  "unk_token": "<unk>"
+}