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,1501 @@
+---
+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: G드라이브는 코로나19 때문에 재택근무가 확대되자 어떻게 활용되었어
+  sentences:
+  - 디지털 시대로의 전환은 정부의 일하는 방식에 변화를 가져왔다. 코로나 19의 확산과 함께 재택근무의 실시로 정부원격근무서비스(GVPN), G드라이브가
+    원격 근무 인프라 및 온라인 협업툴로 활용되었다. GVPN은 공무원이 인터넷이 연결된 곳이라면 국내‧외 출장지나 집에서 사무실처럼 업무를 처리할
+    수 있게 해주는 시스템이다. G드라이브는 정부 클라우드 서비스로 2017년 체계적 지식관리 및 행정 업무의 연속성을 확보하기 위해 서비스를
+    시작하였다. 업무용 컴퓨터 대신 클라우드에 업무계획, 통계, 정책보고서, 업무편람 등 공무원의 업무 및 정책 자료를 저장·관리하게 되었다.
+    공무원은 일하는 방식에 있어 GVPN, G드라이브 활용과 스마트워크센터와 같은 스마트업무환경에 익숙해지고 있다. 그러나 대면문화에 익숙한 조직문화,
+    접근성이 떨어지는 스마트워크센터, 데이터 활용에 대한 공감대 미흡 등의 어려움이 남아있다. 코로나 장기화로 어쩔 수 없이 비대면 문화에 익숙해지고
+    있지만 비대면 환경에서도 업무에 집중할 수 있는 문화로의 전환, 데이터 기반 행정 활성화를 위한 내부 업무 정비 및 표준화 등이 뒷받침되어야
+    할 것이다.
+  - 신종 코로나바이러스 감염증(코로나19) 이후 부상한 긱 이노코미(임시직 경제)가 고용시장을 바꿔놓으면서 ‘긱 워커’를 겨냥한 신생기업(스타트업)들이
+    뜨고 있다. 긱 워커란 회사에 정규직으로 얽매이지 않고 일정 기간 계약을 맺고 일하는 초단기 노동자다. 프리랜서 디자이너나 개발자, 각종 배달원,
+    번역가나 컨설턴트 등이 여기 속한다. 22일 관련업계에 따르면 회사는 정규직 채용보다 비용을 아낄 수 있고, 구직자는 장소와 시간에 구애 받지
+    않고 자유롭게 일하며 동시에 여러 계약으로 수익을 올릴 수 있어서 긱 워커를 선호한다. 특히 긱 워커로 일하는 20,30대 MZ세대(밀레니얼+Z세대)들이
+    늘면서 이들을 겨냥해 사업을 펼치는 스타트업들도 매출이 증가하거나 대규모 투자를 받고 있다. 대표적인 경우가 긱 워커와 기업을 연결해 주는
+    중개 스타트업들이다. 전세계에서 이용자가 가장 많은 미국의 업워크는 3,500가지 분야의 긱 워커 1,200만 명이 이용하고 있다. 이스라엘
+    스타트업 파이버도 디자이너와 개발자 등 400여 직종의 긱 워커들이 이용하면서 지난해 매출이 전년보다 약 78% 성장했다. 2012년 설립된
+    크몽은 국내에서 가장 큰 긱 워커 중개 스타트업이다. 이 업체에 따르면 디자인, 개발자, 영상, 마케팅 등 400여 분야에서 총 25만 명의
+    긱 워커들이 이용해 거래액이 4년 간 10배 이상 급증했다. 특히 이 곳을 통해 계약을 맺은 개발자, 디자이너, 영상 및 음악 전문가의 상위
+    10%는 연 평균 수입이 8,500만~3억4,400만 원에 이른다. 덕분에 크몽은 높은 성장성을 인정 받아 지난 4월 312억 원의 투자를
+    받았다. 스타트업 브레이브모바일도 이사, 청소, 실내장식, 반려동물 훈련, 과외, 심리상담 등 1,000여 가지 분야의 긱 워커를 연결해 주는
+    중개 서비스 ‘숨고’로 지난 14일 320억 원의 투자를 받았다. 이 업체에 따르면 코로나19 이후 각종 가정용 서비스에 대한 수요가 크게
+    늘어 지난해 매출이 전년 대비 160% 이상 성장했다. 숨고의 가입자는 약 500만 명이며 누적으로 3,000만 회 이상 긱 워커들에게 일을
+    제공했다. 채용 플랫폼을 운영하는 원티드는 긱 워커들에게 인공지능(AI)을 이용해 적합한 일자리를 소개하는 ‘원티드 긱스’ 서비스를 아예 따로
+    개발했다. 또 일자리 매니저인 매칭 매니저를 도입해 이들이 해당 일자리에 어울리는 긱 워커를 찾아내 계약부터 업무 진행, 정산까지 모든 과정을
+    1 대 1로 조율한다. 원티드 관계자는 “원티드 긱스 덕분에 등록된 긱 워커가 1년 만에 36배 증가했고 기업들의 채용 의뢰도 10배 늘었다”고
+    말했다. 긱 워커 증가에 맞춰 이들을 위한 스타트업 서비스도 늘고 있다. 금융기술 스타트업 엠마우스는 하나은행, 애큐온저축은행과 함께 긱 워커들에게
+    월급을 가불해 주는 ‘페이워치’ 앱을 선보였��. 긱 워커가 위성위치확인시스템(GPS)을 이용해 이 앱으로 출퇴근을 기록하면 일한 날짜만큼 금액을
+    미리 빌려 쓸 수 있다. 이후 월급을 받을 때 가불액을 제외한 나머지가 입금된다. 세무회계 스타트업 자비스앤빌런즈는 긱 워커를 위한 세무 서비스
+    ‘삼쩜삼’을 운영한다. 세금 환급액을 확인하고 수수료 3.3%를 내면 간편하게 세무신고도 할 수 있는 서비스다. 이런 서비스 덕분에 이 업체는
+    올들어 65억 원을 투자받았다. 관련업계에서는 긱 이코노미 시장이 커지며 긱 워커를 겨냥한 스타트업과 서비스는 계속 늘어날 것으로 보고 있다.
+    이복기 원티드랩 대표는 “2025년까지 긱 이코노미의 부가가치가 2,948조 원에 이를 것이라는 외국 컨설팅 업체의 분석이 있다”며 “긱 워커
+    시장도 계속 커지면서 이들을 겨냥한 서비스 시장도 함께 증가할 것”이라고 전망했다.
+  - 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년 정도 늦어졌으나, 최고경영자로 선임되는
+    나이는 비슷하다. 정광선 한국기업지배구조 개선지원센터 원장(중앙대 교수)은 “재벌총수 일가의 초고속 승진과 조급한 경영승계는 기업을 위험에
+    빠뜨릴 수 있는 만큼 충분한 경영수업과 경영능력에 대한 객관적 검증이 필요하다”고 말했다. 곽정수 대기업전문기자
+- source_sentence: 사천시가 진행하는 신년 맞이 행사에 참여하려면 어떤 동영상을 봐야 해
+  sentences:
+  - 'Ⅱ. 미 연준의 비전통적 통화정책 수행원칙
+
+    이 절에서 우리는 먼저 미국 중앙은행의 제도와 정책이 어떤 특성을 가지고 있는지를 살펴보되, 이후 검토할 비전통적인 통화원칙 논의와 관련이
+    깊은 내용을 중심으로 알아본다. 그리고 금융위기의 과정에서 미 연준이 어떻게 대응하였는지를 알아보고, 마지막으로 이러한 대응과정에서의 원칙이
+    무엇이었는지를 고찰해 본다. 1. 미국 중앙은행 제도와 통화정책의 특성
+
+    미국에서 중앙은행의 역할을 하고 있는 연방준비제도(Federal Reserve System, 이하 연준제도 또는 연준)의 가장 큰 특징은 반관반민(半官半民)의
+    성격이 있다는 점이다. 이 제도를 이루고 있는 세 주체는 연방준비제도이사회, 지역연준, 그리고 연방공개시장위원회이다. 미국의 수도인 워싱턴에
+    위치한 연방준비제도이사회(Federal Reserve Board, 정식명칭은 the Board of Governors of the Federal
+    Reserve System, 이하 연준이사회)는 공공부문의 성격을 띠고 있으나, 20세기 초반의 경제상황을 반영하여 미국 전역에 분포되어 있는
+    12개의 연방준비은행(Federal Reserve Banks, 이하 지역연준)은 법적으로는 완전히 사적인 조직이다. 비록 공공부문이기는 하나
+    연준이사회의 독립성은 14년이라는 이사의 임기와 예산의 독립성으로 보장되어 있으며, 국민에 대한 책임을 진다는 원칙에 따라 연준이사회는 의회에
+    설명할 법적 의무를 진다. 이러한 독립성은 흔히 정부 내에서의 독립(independence within the government)이라고 불리고
+    있다. 전통적인 통화금융정책에서 가장 중요한 수단인 연방기금금리(federal funds rate)를 결정하는 연방공개시장위원회(Federal
+    Open Market Committee, 약어로 FOMC)는 12명으로 구성되어 있다. 연준이사회를 구성하는 7명의 연준이사는 항상 구성원으로
+    포함되며, 12명의 지역연준 총재들 중에서 5명이 투표자로 참가함으로써 총 12명이 투표권을 행사한다. 뉴욕 연준의 총재는 연방공개시장위원회의
+    부의장 자격으로 상시 투표에 참여하고 있으며, 다른 지역연준의 총재들은 2년(시카고 및 클리블랜드 연준) 혹은 3년(나머지 9개 지역연준)마다
+    돌아가며 투표권을 나누어 갖고 있다.'
+  - 경남 사천시가 신축년 새해를 맞아 18일부터 23일까지 공식 유튜브 채널인 「사천TV」 를 통해 댓글 이벤트를 실시한다고 17일 밝혔다. 이번
+    이벤트는 사천바다케이블카, 무지개빛 해안도로 등 다른 관광명소에 비해 덜 알려진 아름다운 사천의 섬을 홍보하려는 취지다. 또 코로나19로 인해
+    사회적 거리두기 등으로 지친 전국 구독자에게 랜선여행을 제공, 여행 갈증을 해소하려고 기획됐다. 이벤트 기간 중 사천시 공식 유튜브 채널 「사천TV」에
+    접속해 ‘사천의 섬’ 영상을 시청한 뒤 영상 속에 등장하는 4개의 섬 이름과 당첨 때 상품권 수령을 위한 이메일을 댓글로 남기면 참여가 완료된다.
+    당첨자는 오는 25일에 발표된다. 참여자 100명을 추첨해 1만원 상당의 모바일 상품권을 준다. 구독하기, 좋아요, 알림 설정을 하면 당첨확률은
+    더 높아진다도 사천시 관계자는 조언했다.
+  - 경상남도, 연말연시·겨울방학 가볼만한 곳 35곳 추천<br>기해년·경자년 해넘이·해맞이 행사 <table><tbody><tr><td>시군</td><td>행사명</td><td>일시</td><td>장소</td><td>내용</td><td>연락처</td></tr><tr><td>창원</td><td>2019년
+    갈무리 및 2020년 새해맞이 타종식</td><td>12.31(화) 23:00~00:30 </td><td>창동 불종거리 </td><td>축하공연,
+    타종행사<br>신년인사 등 </td><td>225-3223 </td></tr><tr><td>창원</td><td>2019년 제야 타종식</td><td>12.31(화)
+    21:00~01:00 </td><td>창원대종각</td><td>식전공연, 타종식<br>신년인사, 합창 등 </td><td>225-3655</td></tr><tr><td>창원</td><td>2020
+    경술년 해맞이행사</td><td>1. 1(수) 06:00~ </td><td>마산합포구 만날공원</td><td>해맞이 방문객 어묵,막걸리 제공
+    등</td><td>220-5443</td></tr><tr><td>창원</td><td>2019년 제야의 종 타종행사</td><td>12.31(화)
+    23:00~00:30</td><td>진해구청 내 종각 앞</td><td>식전공연, 타종식 <br>신년인사, 먹거리부스운영 </td><td>548-4023</td></tr><tr><td>진주</td><td>2019년
+    제야의 종 타종행사</td><td>12.31(화) 22:50~00:50</td><td>진주성 호국 종각</td><td>타종식, 신년메시지<br>축하공연,
+    시민타종 체험<br>떡국 나눔 행사 </td><td>749-6942</td></tr><tr><td>통영</td><td>2020년 통영 해맞이
+    행사</td><td>1. 1(수) 06:00~08:00 </td><td>이순신 공원</td><td>희망찬 새해노래 <br>LED 전기초
+    소원 기원 </td><td>650-4032</td></tr><tr><td>사천</td><td>경자년 새해맞이 해돋이 행사</td><td>1.
+    1(수) 06:30~ </td><td>사천바다케이블카</td><td>순금 1돈 지급 이벤트<br>떡국 나눔 행사 </td><td>831-2780</td></tr><tr><td>김해</td><td>제야음악회
+    및 제야의 종 타종식</td><td>12.31(화) 22:00~00:30</td><td>김해시민의 종각</td><td>제야음악회, 타종식<br>푸드트럭
+    운영<br>소망풍선 날리기 </td><td>330-6844</td></tr><tr><td>거제</td><td>2019년 송년불꽃축제</td><td>12.31.(화)
+    13:00~20:00</td><td>장승포항</td><td>민속문화행사, 축하공연<br>멀티미디어 불꽃쇼 </td><td>639-3392</td></tr><tr><td>거제</td><td>2020년
+    신년 해맞이 축제</td><td>1. 1(수) 06:00~08:00 </td><td>장승포 몽돌개</td><td>민속문화행사, 떡국나눔 </td><td>639-6752</td></tr><tr><td>의령</td><td>2020년
+    부자 솥바위 해맞이 행사</td><td>1. 1(수) 07:00~09:00 </td><td>정암루</td><td>기원제례, 해맞이<br>떡국,
+    복주머니 나눔 </td><td>570-2505</td></tr><tr><td>창녕</td><td>2019년 제야의 종 타종식 행사</td><td>12.31(화)
+    22:30~00:15 </td><td>창녕대종각</td><td>음식나눔행사, 공연행사<br>타종식, 신년 메시지 </td><td>530-1464</td></tr><tr><td>고성</td><td>2020
+    동해면 해맞이 행사</td><td>1. 1(수) 06:30~08:30 </td><td>동해면 해맞이공원</td><td>기원제, 떡국 나눔
+    <br>농악공연, 소원문 풍선판매 </td><td>670-5604</td></tr><tr><td>남해</td><td>2020년 가천다랭이
+    해맞이 행사</td><td>1. 1(수) 06:00~09:00</td><td>가천 다랭이마을</td><td>새해 소망 기원제, 풍물놀이<br>떡국
+    제공(800명)<br>우렁이쌀 1kg 제공(200명) </td><td>860-8595</td></tr><tr><td>하동</td><td>2020년
+    하동 금오산 해맞이 행사</td><td>1. 1(수) 05:30~09:30 </td><td>금오산 정상</td><td>새해맞이 소원성취 기원제<br>떡국
+    및 다과 나눔 <br>짚와이어 무료탑승(40명) </td><td>880-6261</td></tr><tr><td>함양</td><td>2019년
+    제야의 종 타종식</td><td>12.31(화) 23:00~00:30</td><td>군민의 종 종각</td><td>식전행사, 타종행사<br>신년인사,
+    축하공연 </td><td>960-4361</td></tr><tr><td>함양</td><td>2020년 해맞이 행사</td><td>1. 1(수)
+    07:00~09:00 </td><td>백암산 정상</td><td>안녕기원제, 해맞이, <br>희망의 메시지, 떡국 나눔 </td><td>960-4361</td></tr><tr><td>거창</td><td>경자년
+    감악산 해맞이 축제</td><td>1. 1(수) 06:00~09:00 </td><td>감악산 정상</td><td>기원제, 소원풍선날리기<br>풍물놀이,
+    떡국 나눔 </td><td>940-7661</td></tr><tr><td>합천</td><td>합천 떡국나누기 해맞이 행사</td><td>1.
+    1(수) 06:00~09:00 </td><td>합천읍 마령재</td><td>떡국 나눔, 안녕 기원제</td><td>930-4667</td></tr><tr><td>합천</td><td>2019년
+    제야 군민대종 타종행사</td><td>12.31(화) 20:00~01:00 </td><td>대종각 일원 (일해공원)</td><td>식전행사,
+    타종행사</td><td>930-4667</td></tr></tbody></table>
+- source_sentence: 산업부는 국내 중소·중견기업을 어떻게 글로벌 전문기업으로 육성시키려고 해
+  sentences:
+  - 또한 유치원의 방과후 과정 및 어린이집의 특별활동과 사교육 관련 질문을 혼동하는 경우가 있어, 두 질문을 구분할 수 있도록 질문배치와 지침의
+    위치 등을 수정하도록 제안하였다. ‘일반과목’, ‘논술’ 등의 표현이 적절하지 않다는 지적이 있어 구체적으로 표현할 것과, 사교육 이유 항목의
+    표현을 수정할 것을 제안했다. 사교육 시간 항목은 유아 사교육이 분 단위로 짧게 진행되는 경우가 많다는 점을 고려해, 시간 단위로만 응답하던
+    방식에서 시간과 분으로 응답하도록 제안했다. 그 밖에 사교육 과목과 유형, 인적사항 항목 등에 대한 표현 검토를 제안했으며, 가정 양육 조사표의
+    반일제 이상 학원 누락 오류를 줄이기 위해 지침의 배치 등을 조정하도록 했다. 3차 인지면접에서는 2차 인지면접 결과를 반영하여 수정된 조사표의
+    개선효과를 평가하는데 초점을 두었다. 3차 인지면접 결과, 조사표 구조 인식 개선효과는 확인되었지만 여전히 응답오류나 오류 가능성이 발견되었다.
+    따라서 응답오류 방지를 위해 조사표 첫 부분이나 조사 안내문에 전체 조사표 구조에 대한 설명을 제시할 필요가 있어 보인다. 또한 데스크톱이나
+    모바일조사표를 설계할 때, 전체 사교육 과목으로 선택한 과목을 해당 질문에 제시하면서 과목을 강조하여 제시할 필요가 있다.
+  - "글로벌 전문기업 400개 육성을 위한 2차 후보기업 모집 착수\n□ 산업통상자원부(장관 윤상직)는 수출 1억불 이상 글로벌 전문기업 400개\
+    \ 육성(2017년)을 위해 3.3(월)부터 2차 글로벌 전문 후보기업 모집에 들어간다고 밝힘\nㅇ 지난해 9월 산업부는 “글로벌 전문기업\
+    \ 육성 방안”을 발표(경제관계장관회의, 9.23)하고 1차 글로벌 전문 후보기업 46개사를 선정하여 기업의 글로벌화를 위한 다양한 시책을\
+    \ 지원 중에 있음\nㅇ 2차 글로벌 전문 후보기업은 최근 3년간 연간 수출 2천만불 이상 1억불 미만 실적이 있는 중소·중견기업 중에서 수출잠재력,\
+    \ 매출대비 수출비율, 수출확대계획 등을 종���적으로 고려하여 4월 중 선정될 예정\n□ 글로벌 전문 후보기업에 선정된 기업은 4대 플랫폼을\
+    \ 통해 기업 글로벌화를 위한 프리미엄 종합지원 프로그램을 제공받고, 산업부와 유관기관의 기존 시책도 우대*하여 지원받을 수 있음 * IP스타기업(특허청)\
+    \ 선정 평가시 후보기업에 5점 가점 부여, 표준기술력향상사업(국가기술표준원) 평가시 7점 가점 등 \n□ 관심 있는 기업은 4.1일까지 한국산업기술진흥원(KIAT)에\
+    \ 접수신청하면 되며 산업부와 진흥원은 후보기업 선정 평가를 거쳐 4월 중 최종 선정기업을 확정할 예정임 * 사업설명회 일정 : 3.12(수)\
+    \ 15:00 대한상공회의소 국제회의실"
+  - '산업부, 글로벌전문기술개발사업에 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억원을 지원함'
+- source_sentence: 주꾸미어종의 낚시금지기간은 언제야
+  sentences:
+  - 7월 1일부터 낚시어선도 출항 전 비상대응요령 안내 의무화<br>낚시어선의 안전운항 등을 위한 안내(게시용) (예)<br>2. 주요 낚시어종의
+    포획금지 체장․체중 등 수산자원 보호 <table><tbody><tr><td>어종</td><td>금지기간</td><td>금지구역</td><td>금지체장․체중</td></tr><tr><td>주꾸미</td><td>5.11～8.31</td><td>전국</td><td>-</td></tr><tr><td>갈치</td><td>7.1～7.31<br>(근해채낚기어업과
+    연안복합어업 제외)</td><td>전국</td><td>18㎝이하(항문장)</td></tr><tr><td>문치가자미</td><td>12.1～1.31</td><td>전국</td><td>15㎝이하</td></tr><tr><td>넙치</td><td>-</td><td>-</td><td>21㎝이하</td></tr><tr><td>농어</td><td>-</td><td>-</td><td>30㎝이하</td></tr></tbody></table>
+  - '인천시 주꾸미 방류..“잘 커서 돌아올게요!” - 자체 생산 주꾸미 수산종자 50만여 마리를 인천 바다에 방류 -
+
+    인천광역시(시장 박남춘)는 수산자원연구소에서 자체 생산한 주꾸미 수산종자 50만여 마리를 7월 말까지 인천 앞바다에 방류한다고 밝혔다. 이번에
+    생산한 주꾸미 수산종자는 50일 동안 대량양식 기술을 통해 생산한 우량 수산종자이다. 방류해역은 사전에 조사된 인천 주꾸미 서식지 4곳으로
+    각각 ▲영흥해역(20만3천 마리), ▲강화군 동검도(10만 마리), ▲중구 영종(15만 마리), ▲옹진군 대이작도(5만 마리)이다. 어업인과
+    낚시인 모두에게 인기 있는 주꾸미는 급격한 생산량 감소로 산란기 금어기(5. 11.~8. 31.)와 시범방류 품종 지정 등 자원회복을 위한
+    정부 정책이 시행 중이다. * 주꾸미 금어기: 2018년부터 시행
+
+    ** 해양수산부 수산종자 방류 지침: 2019년부터 시범방류 품종'
+  - 해양수산부는 어업이나 양식업에 종사하면서 어촌의 발전을 이끌어나갈 '수산업경영인'을 다음 달 28일까지 모집한다고 밝혔다. 수산업경영인은 어업
+    종사 경력에 따라 '어업인후계자'와 '우수경영인' 등 2단계로 나뉜다. 어업인후계자는 만 50세 미만이고 어업분야 종사 경력이 없거나 10년
+    미만인 사람 중에서 선정한다. 우수경영인은 만 60세 이하로 어업인후계자 선정 후 5년 이상 지난 사람 가운데에서 선발한다. 어업인후계자는
+    연간 금리 2％와 10년 상환의 조건으로 최대 3억 원까지, 우수경영인��� 연리 1％와 15년 상환 조건으로 최대 2억 원까지 융자 지원을 받을
+    수 있다. 신청은 각 지방자치단체에 하면 된다. 해수부는 어업인후계자 300명, 우수경영인 50명을 선발해 4월 중 해당 지자체에 공지할 예정이다.
+- source_sentence: 안정적인 경제성장과 소비 증가 등 능력을 키우고 있으며 인구 6억 3000만 명의 거대 경제권으로 구성된 동남아시아
+    단체는 뭐지
+  sentences:
+  - 중국의 창지투개발계획 등 동북지역 개발전략은 동북아에서 실질적으로 개발협력의 기회를 제공한다는 점에서 중요한 의미를 가진다. 중국 동북지역은
+    인구가 1억명을 초과하고, 세계 20위권국가 규모에 해당하는 8,000억 달러의 GDP(2012년)와 높은 경제성장률을 보이고 있는 지역으로
+    최근 러시아 극동지역과 한반도 북부를 포함하는 동북아 지역개발의 실질적인 중심역할을 하고 있다. 북한은 두만강유역에서의 개발을 추진할 능력을
+    보유하지 못하고 있고, 러시아는 비록 동북아에서의 전략적 지위 확보에 관심이 있지만 실질적인 개발투자를 실행할 능력은 보유하고 있지 못하며,
+    남한도 동북아지역의 개발을 주도할 만한 전략과 자금력을 갖추고 있지 못하다는 점에서 중국 주도의 두만강유역 개발을 부정적으로만 평가할 수 없는
+    상황이라 할 수 있다. 따라서, 한국은 중국 및 러시아와 두만강유역에서의 적극적 협력을 통해 남, 북, 중, 러 네 나라의 공동이익을 최대화하면서
+    한반도경제와 대륙경제의 통합을 위한 장기포석을 마련할 필요가 있다.
+  - "자연‧문화 자원 조사현황\x03<br> 문화경관 자원 <table><tbody><tr><td colspan='2'>구분</td><td>명칭</td><td>지정번호</td><td>비고</td></tr><tr><td\
+    \ colspan='3'>합계</td><td>18점</td><td> </td></tr><tr><td rowspan='12'>국가 지정</td><td\
+    \ rowspan='10'>천연기념물(10)</td><td>봉화석포면 열목어서식지</td><td>제74호</td><td> </td></tr><tr><td>산양</td><td>제217호</td><td>\
+    \ </td></tr><tr><td>하늘다람쥐</td><td>제328호</td><td> </td></tr><tr><td>원앙</td><td>제327호</td><td>\
+    \ </td></tr><tr><td>매</td><td>제323-7호</td><td> </td></tr><tr><td>독수리</td><td>제243-1호</td><td>\
+    \ </td></tr><tr><td>붉은배새매</td><td>제323-2호</td><td> </td></tr><tr><td>검독수리</td><td>제243호</td><td>\
+    \ </td></tr><tr><td>두견이</td><td>제447호</td><td> </td></tr><tr><td>소쩍새</td><td>제324호</td><td>\
+    \ </td></tr><tr><td>명승(1)</td><td>태백 검룡소</td><td>제73호</td><td> </td></tr><tr><td>중요민속문화재(1)</td><td>태백산\
+    \ 천제단</td><td>제228호</td><td> </td></tr><tr><td>지방 지정</td><td>강원도 민속문화재(1)</td><td>태백산\
+    \ 석장승</td><td>제4호</td><td> </td></tr><tr><td>기타</td><td>민속자원(5)</td><td>검룡소(儉龍沼)기우제(祈雨祭),\
+    \ 두문동재, 불바래기, 창죽, 예터</td><td> </td><td> </td></tr></tbody></table> [주요 문화경관 자원\
+    \ 현황]"
+  - 2008년 금융위기 이후 세계경제의 전반적 침체는 수출주도 성장을 지속해온 우리나라 경제에 위기를 가져왔다. 우리 경제는 위기 극복을 위해
+    내수시장 활성화 등의 정책을 제시하고 있으나, 아직까지 뚜렷한 반전의 모멘텀을 찾지 못한 것으로 판단된다. 그러므로 대외의존도가 높은 우리나라의
+    경제구조하에서 위기 극복은 수출 및 무역의 확대를 통해 이루어져야 한다. 이러한 측면에서 볼 때 최근 ASEAN 경제 통합 강화 흐름은 활용
+    여하에 따라 우리가 처한 경제 위기를 극복할 수 있는 하나의 단초를 제공할 수 있다. 동남아시아 10개 국가로 구성된 아세안은 인구 6억 3,000만명의
+    거대 경제권으로 최근 안정적인 경제성장, 중산층 확대에 따른 소비증대, 젊은층의 비중이 높은 인구학적 장점 등은 시장 및 생산기반으로서의 잠재력을
+    점증시키고 있다.
+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-neg-bs320-5e-5-1000")
+# Run inference
+sentences = [
+    '안정적인 경제성장과 소비 증가 등 능력을 키우고 있으며 인구 6억 3000만 명의 거대 경제권으로 구성된 동남아시아 단체는 뭐지',
+    '2008년 금융위기 이후 세계경제의 전반적 침체는 수출주도 성장을 지속해온 우리나라 경제에 위기를 가져왔다. 우리 경제는 위기 극복을 위해 내수시장 활성화 등의 정책을 제시하고 있으나, 아직까지 뚜렷한 반전의 모멘텀을 찾지 못한 것으로 판단된다. 그러므로 대외의존도가 높은 우리나라의 경제구조하에서 위기 극복은 수출 및 무역의 확대를 통해 이루어져야 한다. 이러한 측면에서 볼 때 최근 ASEAN 경제 통합 강화 흐름은 활용 여하에 따라 우리가 처한 경제 위기를 극복할 수 있는 하나의 단초를 제공할 수 있다. 동남아시아 10개 국가로 구성된 아세안은 인구 6억 3,000만명의 거대 경제권으로 최근 안정적인 경제성장, 중산층 확대에 따른 소비증대, 젊은층의 비중이 높은 인구학적 장점 등은 시장 및 생산기반으로서의 잠재력을 점증시키고 있다.',
+    '중국의 창지투개발계획 등 동북지역 개발전략은 동북아에서 실질적으로 개발협력의 기회를 제공한다는 점에서 중요한 의미를 가진다. 중국 동북지역은 인구가 1억명을 초과하고, 세계 20위권국가 규모에 해당하는 8,000억 달러의 GDP(2012년)와 높은 경제성장률을 보이고 있는 지역으로 최근 러시아 극동지역과 한반도 북부를 포함하는 동북아 지역개발의 실질적인 중심역할을 하고 있다. 북한은 두만강유역에서의 개발을 추진할 능력을 보유하지 못하고 있고, 러시아는 비록 동북아에서의 전략적 지위 확보에 관심이 있지만 실질적인 개발투자를 실행할 능력은 보유하고 있지 못하며, 남한도 동북아지역의 개발을 주도할 만한 전략과 자금력을 갖추고 있지 못하다는 점에서 중국 주도의 두만강유역 개발을 부정적으로만 평가할 수 없는 상황이라 할 수 있다. 따라서, 한국은 중국 및 러시아와 두만강유역에서의 적극적 협력을 통해 남, 북, 중, 러 네 나라의 공동이익을 최대화하면서 한반도경제와 대륙경제의 통합을 위한 장기포석을 마련할 필요가 있다.',
+]
+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`: 80
+- `per_device_eval_batch_size`: 80
+- `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`: 80
+- `per_device_eval_batch_size`: 80
+- `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.0007 | 1    | 0.6586        |
+| 0.0013 | 2    | 0.6342        |
+| 0.0020 | 3    | 0.6724        |
+| 0.0027 | 4    | 0.697         |
+| 0.0033 | 5    | 0.657         |
+| 0.0040 | 6    | 0.5993        |
+| 0.0046 | 7    | 0.68          |
+| 0.0053 | 8    | 0.6296        |
+| 0.0060 | 9    | 0.7052        |
+| 0.0066 | 10   | 0.6982        |
+| 0.0073 | 11   | 0.6726        |
+| 0.0080 | 12   | 0.6552        |
+| 0.0086 | 13   | 0.6707        |
+| 0.0093 | 14   | 0.6253        |
+| 0.0099 | 15   | 0.6869        |
+| 0.0106 | 16   | 0.6612        |
+| 0.0113 | 17   | 0.66          |
+| 0.0119 | 18   | 0.6964        |
+| 0.0126 | 19   | 0.6654        |
+| 0.0133 | 20   | 0.669         |
+| 0.0139 | 21   | 0.6045        |
+| 0.0146 | 22   | 0.6441        |
+| 0.0153 | 23   | 0.6053        |
+| 0.0159 | 24   | 0.6318        |
+| 0.0166 | 25   | 0.6073        |
+| 0.0172 | 26   | 0.6288        |
+| 0.0179 | 27   | 0.5385        |
+| 0.0186 | 28   | 0.5787        |
+| 0.0192 | 29   | 0.5824        |
+| 0.0199 | 30   | 0.5535        |
+| 0.0206 | 31   | 0.5498        |
+| 0.0212 | 32   | 0.5915        |
+| 0.0219 | 33   | 0.5458        |
+| 0.0225 | 34   | 0.4879        |
+| 0.0232 | 35   | 0.4858        |
+| 0.0239 | 36   | 0.4651        |
+| 0.0245 | 37   | 0.5266        |
+| 0.0252 | 38   | 0.4629        |
+| 0.0259 | 39   | 0.4618        |
+| 0.0265 | 40   | 0.4657        |
+| 0.0272 | 41   | 0.4514        |
+| 0.0279 | 42   | 0.477         |
+| 0.0285 | 43   | 0.395         |
+| 0.0292 | 44   | 0.4078        |
+| 0.0298 | 45   | 0.4812        |
+| 0.0305 | 46   | 0.4056        |
+| 0.0312 | 47   | 0.3871        |
+| 0.0318 | 48   | 0.4371        |
+| 0.0325 | 49   | 0.3622        |
+| 0.0332 | 50   | 0.3433        |
+| 0.0338 | 51   | 0.3659        |
+| 0.0345 | 52   | 0.3752        |
+| 0.0351 | 53   | 0.354         |
+| 0.0358 | 54   | 0.3869        |
+| 0.0365 | 55   | 0.3168        |
+| 0.0371 | 56   | 0.3576        |
+| 0.0378 | 57   | 0.3096        |
+| 0.0385 | 58   | 0.3043        |
+| 0.0391 | 59   | 0.3192        |
+| 0.0398 | 60   | 0.2984        |
+| 0.0405 | 61   | 0.3342        |
+| 0.0411 | 62   | 0.3186        |
+| 0.0418 | 63   | 0.2638        |
+| 0.0424 | 64   | 0.2813        |
+| 0.0431 | 65   | 0.323         |
+| 0.0438 | 66   | 0.2617        |
+| 0.0444 | 67   | 0.2497        |
+| 0.0451 | 68   | 0.2694        |
+| 0.0458 | 69   | 0.2684        |
+| 0.0464 | 70   | 0.2875        |
+| 0.0471 | 71   | 0.2759        |
+| 0.0477 | 72   | 0.261         |
+| 0.0484 | 73   | 0.2537        |
+| 0.0491 | 74   | 0.2294        |
+| 0.0497 | 75   | 0.2082        |
+| 0.0504 | 76   | 0.2253        |
+| 0.0511 | 77   | 0.2389        |
+| 0.0517 | 78   | 0.2072        |
+| 0.0524 | 79   | 0.259         |
+| 0.0531 | 80   | 0.2115        |
+| 0.0537 | 81   | 0.2226        |
+| 0.0544 | 82   | 0.1994        |
+| 0.0550 | 83   | 0.2424        |
+| 0.0557 | 84   | 0.232         |
+| 0.0564 | 85   | 0.2316        |
+| 0.0570 | 86   | 0.2015        |
+| 0.0577 | 87   | 0.2147        |
+| 0.0584 | 88   | 0.2239        |
+| 0.0590 | 89   | 0.2284        |
+| 0.0597 | 90   | 0.2279        |
+| 0.0603 | 91   | 0.2163        |
+| 0.0610 | 92   | 0.1895        |
+| 0.0617 | 93   | 0.1955        |
+| 0.0623 | 94   | 0.2175        |
+| 0.0630 | 95   | 0.1966        |
+| 0.0637 | 96   | 0.2441        |
+| 0.0643 | 97   | 0.2131        |
+| 0.0650 | 98   | 0.237         |
+| 0.0656 | 99   | 0.2204        |
+| 0.0663 | 100  | 0.2301        |
+| 0.0670 | 101  | 0.2592        |
+| 0.0676 | 102  | 0.2242        |
+| 0.0683 | 103  | 0.1647        |
+| 0.0690 | 104  | 0.1974        |
+| 0.0696 | 105  | 0.1918        |
+| 0.0703 | 106  | 0.1961        |
+| 0.0710 | 107  | 0.2344        |
+| 0.0716 | 108  | 0.2616        |
+| 0.0723 | 109  | 0.1813        |
+| 0.0729 | 110  | 0.181         |
+| 0.0736 | 111  | 0.2045        |
+| 0.0743 | 112  | 0.2018        |
+| 0.0749 | 113  | 0.2022        |
+| 0.0756 | 114  | 0.182         |
+| 0.0763 | 115  | 0.205         |
+| 0.0769 | 116  | 0.1964        |
+| 0.0776 | 117  | 0.1752        |
+| 0.0782 | 118  | 0.1688        |
+| 0.0789 | 119  | 0.2009        |
+| 0.0796 | 120  | 0.1656        |
+| 0.0802 | 121  | 0.1829        |
+| 0.0809 | 122  | 0.1883        |
+| 0.0816 | 123  | 0.1837        |
+| 0.0822 | 124  | 0.1918        |
+| 0.0829 | 125  | 0.2356        |
+| 0.0836 | 126  | 0.1985        |
+| 0.0842 | 127  | 0.148         |
+| 0.0849 | 128  | 0.2113        |
+| 0.0855 | 129  | 0.2067        |
+| 0.0862 | 130  | 0.1708        |
+| 0.0869 | 131  | 0.1811        |
+| 0.0875 | 132  | 0.2077        |
+| 0.0882 | 133  | 0.176         |
+| 0.0889 | 134  | 0.1728        |
+| 0.0895 | 135  | 0.2019        |
+| 0.0902 | 136  | 0.1793        |
+| 0.0908 | 137  | 0.1838        |
+| 0.0915 | 138  | 0.1819        |
+| 0.0922 | 139  | 0.1953        |
+| 0.0928 | 140  | 0.1803        |
+| 0.0935 | 141  | 0.1871        |
+| 0.0942 | 142  | 0.2002        |
+| 0.0948 | 143  | 0.2085        |
+| 0.0955 | 144  | 0.164         |
+| 0.0962 | 145  | 0.1886        |
+| 0.0968 | 146  | 0.1814        |
+| 0.0975 | 147  | 0.1801        |
+| 0.0981 | 148  | 0.2046        |
+| 0.0988 | 149  | 0.1829        |
+| 0.0995 | 150  | 0.2409        |
+| 0.1001 | 151  | 0.2051        |
+| 0.1008 | 152  | 0.1791        |
+| 0.1015 | 153  | 0.1738        |
+| 0.1021 | 154  | 0.1972        |
+| 0.1028 | 155  | 0.1674        |
+| 0.1034 | 156  | 0.1743        |
+| 0.1041 | 157  | 0.1784        |
+| 0.1048 | 158  | 0.1728        |
+| 0.1054 | 159  | 0.1648        |
+| 0.1061 | 160  | 0.1597        |
+| 0.1068 | 161  | 0.1476        |
+| 0.1074 | 162  | 0.2036        |
+| 0.1081 | 163  | 0.1591        |
+| 0.1088 | 164  | 0.1471        |
+| 0.1094 | 165  | 0.2037        |
+| 0.1101 | 166  | 0.172         |
+| 0.1107 | 167  | 0.1892        |
+| 0.1114 | 168  | 0.1691        |
+| 0.1121 | 169  | 0.1725        |
+| 0.1127 | 170  | 0.1719        |
+| 0.1134 | 171  | 0.2146        |
+| 0.1141 | 172  | 0.162         |
+| 0.1147 | 173  | 0.1972        |
+| 0.1154 | 174  | 0.2149        |
+| 0.1160 | 175  | 0.197         |
+| 0.1167 | 176  | 0.1786        |
+| 0.1174 | 177  | 0.1904        |
+| 0.1180 | 178  | 0.1491        |
+| 0.1187 | 179  | 0.2163        |
+| 0.1194 | 180  | 0.1741        |
+| 0.1200 | 181  | 0.1564        |
+| 0.1207 | 182  | 0.1577        |
+| 0.1214 | 183  | 0.1923        |
+| 0.1220 | 184  | 0.1492        |
+| 0.1227 | 185  | 0.1421        |
+| 0.1233 | 186  | 0.1939        |
+| 0.1240 | 187  | 0.1613        |
+| 0.1247 | 188  | 0.1675        |
+| 0.1253 | 189  | 0.1751        |
+| 0.1260 | 190  | 0.2026        |
+| 0.1267 | 191  | 0.2061        |
+| 0.1273 | 192  | 0.1848        |
+| 0.1280 | 193  | 0.1647        |
+| 0.1286 | 194  | 0.1674        |
+| 0.1293 | 195  | 0.1686        |
+| 0.1300 | 196  | 0.1657        |
+| 0.1306 | 197  | 0.1594        |
+| 0.1313 | 198  | 0.1717        |
+| 0.1320 | 199  | 0.1724        |
+| 0.1326 | 200  | 0.1785        |
+| 0.1333 | 201  | 0.195         |
+| 0.1340 | 202  | 0.1678        |
+| 0.1346 | 203  | 0.1819        |
+| 0.1353 | 204  | 0.1544        |
+| 0.1359 | 205  | 0.1588        |
+| 0.1366 | 206  | 0.1874        |
+| 0.1373 | 207  | 0.1476        |
+| 0.1379 | 208  | 0.1879        |
+| 0.1386 | 209  | 0.2016        |
+| 0.1393 | 210  | 0.1687        |
+| 0.1399 | 211  | 0.1813        |
+| 0.1406 | 212  | 0.1486        |
+| 0.1412 | 213  | 0.1789        |
+| 0.1419 | 214  | 0.1789        |
+| 0.1426 | 215  | 0.1659        |
+| 0.1432 | 216  | 0.1796        |
+| 0.1439 | 217  | 0.1343        |
+| 0.1446 | 218  | 0.156         |
+| 0.1452 | 219  | 0.2493        |
+| 0.1459 | 220  | 0.1642        |
+| 0.1466 | 221  | 0.1898        |
+| 0.1472 | 222  | 0.1941        |
+| 0.1479 | 223  | 0.1472        |
+| 0.1485 | 224  | 0.1587        |
+| 0.1492 | 225  | 0.1672        |
+| 0.1499 | 226  | 0.2136        |
+| 0.1505 | 227  | 0.1525        |
+| 0.1512 | 228  | 0.1812        |
+| 0.1519 | 229  | 0.1795        |
+| 0.1525 | 230  | 0.2038        |
+| 0.1532 | 231  | 0.1741        |
+| 0.1538 | 232  | 0.1738        |
+| 0.1545 | 233  | 0.1837        |
+| 0.1552 | 234  | 0.1684        |
+| 0.1558 | 235  | 0.1714        |
+| 0.1565 | 236  | 0.163         |
+| 0.1572 | 237  | 0.1821        |
+| 0.1578 | 238  | 0.2023        |
+| 0.1585 | 239  | 0.1699        |
+| 0.1592 | 240  | 0.1758        |
+| 0.1598 | 241  | 0.1864        |
+| 0.1605 | 242  | 0.1417        |
+| 0.1611 | 243  | 0.1925        |
+| 0.1618 | 244  | 0.1742        |
+| 0.1625 | 245  | 0.1462        |
+| 0.1631 | 246  | 0.1569        |
+| 0.1638 | 247  | 0.192         |
+| 0.1645 | 248  | 0.1698        |
+| 0.1651 | 249  | 0.1934        |
+| 0.1658 | 250  | 0.2018        |
+| 0.1664 | 251  | 0.164         |
+| 0.1671 | 252  | 0.1359        |
+| 0.1678 | 253  | 0.1963        |
+| 0.1684 | 254  | 0.1888        |
+| 0.1691 | 255  | 0.1725        |
+| 0.1698 | 256  | 0.1814        |
+| 0.1704 | 257  | 0.1815        |
+| 0.1711 | 258  | 0.1673        |
+| 0.1718 | 259  | 0.1751        |
+| 0.1724 | 260  | 0.1725        |
+| 0.1731 | 261  | 0.207         |
+| 0.1737 | 262  | 0.1827        |
+| 0.1744 | 263  | 0.1755        |
+| 0.1751 | 264  | 0.1541        |
+| 0.1757 | 265  | 0.1822        |
+| 0.1764 | 266  | 0.1863        |
+| 0.1771 | 267  | 0.1591        |
+| 0.1777 | 268  | 0.2115        |
+| 0.1784 | 269  | 0.1397        |
+| 0.1790 | 270  | 0.1835        |
+| 0.1797 | 271  | 0.1637        |
+| 0.1804 | 272  | 0.1803        |
+| 0.1810 | 273  | 0.1446        |
+| 0.1817 | 274  | 0.1914        |
+| 0.1824 | 275  | 0.1642        |
+| 0.1830 | 276  | 0.1537        |
+| 0.1837 | 277  | 0.1639        |
+| 0.1844 | 278  | 0.1961        |
+| 0.1850 | 279  | 0.1392        |
+| 0.1857 | 280  | 0.1644        |
+| 0.1863 | 281  | 0.1802        |
+| 0.1870 | 282  | 0.1483        |
+| 0.1877 | 283  | 0.1611        |
+| 0.1883 | 284  | 0.1617        |
+| 0.1890 | 285  | 0.1523        |
+| 0.1897 | 286  | 0.2163        |
+| 0.1903 | 287  | 0.1801        |
+| 0.1910 | 288  | 0.162         |
+| 0.1916 | 289  | 0.1845        |
+| 0.1923 | 290  | 0.1683        |
+| 0.1930 | 291  | 0.1664        |
+| 0.1936 | 292  | 0.1571        |
+| 0.1943 | 293  | 0.141         |
+| 0.1950 | 294  | 0.168         |
+| 0.1956 | 295  | 0.1879        |
+| 0.1963 | 296  | 0.1566        |
+| 0.1969 | 297  | 0.1592        |
+| 0.1976 | 298  | 0.1592        |
+| 0.1983 | 299  | 0.1829        |
+| 0.1989 | 300  | 0.145         |
+| 0.1996 | 301  | 0.1778        |
+| 0.2003 | 302  | 0.1477        |
+| 0.2009 | 303  | 0.169         |
+| 0.2016 | 304  | 0.1498        |
+| 0.2023 | 305  | 0.1663        |
+| 0.2029 | 306  | 0.1726        |
+| 0.2036 | 307  | 0.1579        |
+| 0.2042 | 308  | 0.1665        |
+| 0.2049 | 309  | 0.1779        |
+| 0.2056 | 310  | 0.1581        |
+| 0.2062 | 311  | 0.168         |
+| 0.2069 | 312  | 0.1883        |
+| 0.2076 | 313  | 0.1418        |
+| 0.2082 | 314  | 0.123         |
+| 0.2089 | 315  | 0.1688        |
+| 0.2095 | 316  | 0.1573        |
+| 0.2102 | 317  | 0.1902        |
+| 0.2109 | 318  | 0.1524        |
+| 0.2115 | 319  | 0.1767        |
+| 0.2122 | 320  | 0.1516        |
+| 0.2129 | 321  | 0.1454        |
+| 0.2135 | 322  | 0.1803        |
+| 0.2142 | 323  | 0.1475        |
+| 0.2149 | 324  | 0.1442        |
+| 0.2155 | 325  | 0.1488        |
+| 0.2162 | 326  | 0.1638        |
+| 0.2168 | 327  | 0.1608        |
+| 0.2175 | 328  | 0.1525        |
+| 0.2182 | 329  | 0.1929        |
+| 0.2188 | 330  | 0.1932        |
+| 0.2195 | 331  | 0.171         |
+| 0.2202 | 332  | 0.1769        |
+| 0.2208 | 333  | 0.122         |
+| 0.2215 | 334  | 0.1556        |
+| 0.2221 | 335  | 0.155         |
+| 0.2228 | 336  | 0.1749        |
+| 0.2235 | 337  | 0.1539        |
+| 0.2241 | 338  | 0.166         |
+| 0.2248 | 339  | 0.1552        |
+| 0.2255 | 340  | 0.1924        |
+| 0.2261 | 341  | 0.1437        |
+| 0.2268 | 342  | 0.1501        |
+| 0.2275 | 343  | 0.1688        |
+| 0.2281 | 344  | 0.1639        |
+| 0.2288 | 345  | 0.154         |
+| 0.2294 | 346  | 0.1346        |
+| 0.2301 | 347  | 0.1771        |
+| 0.2308 | 348  | 0.1403        |
+| 0.2314 | 349  | 0.1958        |
+| 0.2321 | 350  | 0.1482        |
+| 0.2328 | 351  | 0.1622        |
+| 0.2334 | 352  | 0.1493        |
+| 0.2341 | 353  | 0.135         |
+| 0.2347 | 354  | 0.167         |
+| 0.2354 | 355  | 0.1544        |
+| 0.2361 | 356  | 0.1763        |
+| 0.2367 | 357  | 0.1783        |
+| 0.2374 | 358  | 0.1724        |
+| 0.2381 | 359  | 0.153         |
+| 0.2387 | 360  | 0.1516        |
+| 0.2394 | 361  | 0.1353        |
+| 0.2401 | 362  | 0.1623        |
+| 0.2407 | 363  | 0.1794        |
+| 0.2414 | 364  | 0.1495        |
+| 0.2420 | 365  | 0.1562        |
+| 0.2427 | 366  | 0.1887        |
+| 0.2434 | 367  | 0.1577        |
+| 0.2440 | 368  | 0.1501        |
+| 0.2447 | 369  | 0.156         |
+| 0.2454 | 370  | 0.1869        |
+| 0.2460 | 371  | 0.1649        |
+| 0.2467 | 372  | 0.128         |
+| 0.2473 | 373  | 0.1569        |
+| 0.2480 | 374  | 0.1598        |
+| 0.2487 | 375  | 0.146         |
+| 0.2493 | 376  | 0.1404        |
+| 0.25   | 377  | 0.1441        |
+| 0.2507 | 378  | 0.1738        |
+| 0.2513 | 379  | 0.1358        |
+| 0.2520 | 380  | 0.1828        |
+| 0.2527 | 381  | 0.1952        |
+| 0.2533 | 382  | 0.1575        |
+| 0.2540 | 383  | 0.1582        |
+| 0.2546 | 384  | 0.1729        |
+| 0.2553 | 385  | 0.199         |
+| 0.2560 | 386  | 0.1673        |
+| 0.2566 | 387  | 0.1369        |
+| 0.2573 | 388  | 0.1232        |
+| 0.2580 | 389  | 0.167         |
+| 0.2586 | 390  | 0.1838        |
+| 0.2593 | 391  | 0.1593        |
+| 0.2599 | 392  | 0.1724        |
+| 0.2606 | 393  | 0.1795        |
+| 0.2613 | 394  | 0.195         |
+| 0.2619 | 395  | 0.1255        |
+| 0.2626 | 396  | 0.157         |
+| 0.2633 | 397  | 0.1512        |
+| 0.2639 | 398  | 0.1472        |
+| 0.2646 | 399  | 0.1846        |
+| 0.2653 | 400  | 0.1793        |
+| 0.2659 | 401  | 0.1451        |
+| 0.2666 | 402  | 0.1979        |
+| 0.2672 | 403  | 0.1612        |
+| 0.2679 | 404  | 0.1481        |
+| 0.2686 | 405  | 0.159         |
+| 0.2692 | 406  | 0.125         |
+| 0.2699 | 407  | 0.1808        |
+| 0.2706 | 408  | 0.1722        |
+| 0.2712 | 409  | 0.1838        |
+| 0.2719 | 410  | 0.1523        |
+| 0.2725 | 411  | 0.1686        |
+| 0.2732 | 412  | 0.1659        |
+| 0.2739 | 413  | 0.1474        |
+| 0.2745 | 414  | 0.1498        |
+| 0.2752 | 415  | 0.1775        |
+| 0.2759 | 416  | 0.1258        |
+| 0.2765 | 417  | 0.1594        |
+| 0.2772 | 418  | 0.1574        |
+| 0.2779 | 419  | 0.1879        |
+| 0.2785 | 420  | 0.1455        |
+| 0.2792 | 421  | 0.1745        |
+| 0.2798 | 422  | 0.164         |
+| 0.2805 | 423  | 0.1375        |
+| 0.2812 | 424  | 0.163         |
+| 0.2818 | 425  | 0.1338        |
+| 0.2825 | 426  | 0.1933        |
+| 0.2832 | 427  | 0.1464        |
+| 0.2838 | 428  | 0.1534        |
+| 0.2845 | 429  | 0.1407        |
+| 0.2851 | 430  | 0.1574        |
+| 0.2858 | 431  | 0.1379        |
+| 0.2865 | 432  | 0.1525        |
+| 0.2871 | 433  | 0.1533        |
+| 0.2878 | 434  | 0.1646        |
+| 0.2885 | 435  | 0.16          |
+| 0.2891 | 436  | 0.1676        |
+| 0.2898 | 437  | 0.1352        |
+| 0.2905 | 438  | 0.1571        |
+| 0.2911 | 439  | 0.1721        |
+| 0.2918 | 440  | 0.1574        |
+| 0.2924 | 441  | 0.1369        |
+| 0.2931 | 442  | 0.1477        |
+| 0.2938 | 443  | 0.1819        |
+| 0.2944 | 444  | 0.1698        |
+| 0.2951 | 445  | 0.1885        |
+| 0.2958 | 446  | 0.1412        |
+| 0.2964 | 447  | 0.1522        |
+| 0.2971 | 448  | 0.171         |
+| 0.2977 | 449  | 0.1673        |
+| 0.2984 | 450  | 0.1413        |
+| 0.2991 | 451  | 0.1436        |
+| 0.2997 | 452  | 0.1618        |
+| 0.3004 | 453  | 0.1869        |
+| 0.3011 | 454  | 0.1527        |
+| 0.3017 | 455  | 0.1392        |
+| 0.3024 | 456  | 0.1651        |
+| 0.3031 | 457  | 0.1597        |
+| 0.3037 | 458  | 0.1931        |
+| 0.3044 | 459  | 0.1726        |
+| 0.3050 | 460  | 0.208         |
+| 0.3057 | 461  | 0.1488        |
+| 0.3064 | 462  | 0.1361        |
+| 0.3070 | 463  | 0.169         |
+| 0.3077 | 464  | 0.1576        |
+| 0.3084 | 465  | 0.1777        |
+| 0.3090 | 466  | 0.1475        |
+| 0.3097 | 467  | 0.1574        |
+| 0.3103 | 468  | 0.1778        |
+| 0.3110 | 469  | 0.1503        |
+| 0.3117 | 470  | 0.1509        |
+| 0.3123 | 471  | 0.1686        |
+| 0.3130 | 472  | 0.1445        |
+| 0.3137 | 473  | 0.1562        |
+| 0.3143 | 474  | 0.1554        |
+| 0.3150 | 475  | 0.1494        |
+| 0.3156 | 476  | 0.1376        |
+| 0.3163 | 477  | 0.1409        |
+| 0.3170 | 478  | 0.1821        |
+| 0.3176 | 479  | 0.144         |
+| 0.3183 | 480  | 0.196         |
+| 0.3190 | 481  | 0.1643        |
+| 0.3196 | 482  | 0.1797        |
+| 0.3203 | 483  | 0.1525        |
+| 0.3210 | 484  | 0.1532        |
+| 0.3216 | 485  | 0.1642        |
+| 0.3223 | 486  | 0.1552        |
+| 0.3229 | 487  | 0.151         |
+| 0.3236 | 488  | 0.1689        |
+| 0.3243 | 489  | 0.1379        |
+| 0.3249 | 490  | 0.1493        |
+| 0.3256 | 491  | 0.143         |
+| 0.3263 | 492  | 0.1344        |
+| 0.3269 | 493  | 0.1635        |
+| 0.3276 | 494  | 0.1583        |
+| 0.3282 | 495  | 0.1413        |
+| 0.3289 | 496  | 0.1541        |
+| 0.3296 | 497  | 0.1406        |
+| 0.3302 | 498  | 0.1869        |
+| 0.3309 | 499  | 0.1212        |
+| 0.3316 | 500  | 0.1671        |
+| 0.3322 | 501  | 0.1458        |
+| 0.3329 | 502  | 0.1581        |
+| 0.3336 | 503  | 0.143         |
+| 0.3342 | 504  | 0.1623        |
+| 0.3349 | 505  | 0.1499        |
+| 0.3355 | 506  | 0.1613        |
+| 0.3362 | 507  | 0.1778        |
+| 0.3369 | 508  | 0.145         |
+| 0.3375 | 509  | 0.1725        |
+| 0.3382 | 510  | 0.1446        |
+| 0.3389 | 511  | 0.1301        |
+| 0.3395 | 512  | 0.146         |
+| 0.3402 | 513  | 0.1352        |
+| 0.3408 | 514  | 0.1462        |
+| 0.3415 | 515  | 0.1585        |
+| 0.3422 | 516  | 0.1566        |
+| 0.3428 | 517  | 0.128         |
+| 0.3435 | 518  | 0.1547        |
+| 0.3442 | 519  | 0.1532        |
+| 0.3448 | 520  | 0.1522        |
+| 0.3455 | 521  | 0.1277        |
+| 0.3462 | 522  | 0.1482        |
+| 0.3468 | 523  | 0.1356        |
+| 0.3475 | 524  | 0.1564        |
+| 0.3481 | 525  | 0.1525        |
+| 0.3488 | 526  | 0.1639        |
+| 0.3495 | 527  | 0.1377        |
+| 0.3501 | 528  | 0.1811        |
+| 0.3508 | 529  | 0.1376        |
+| 0.3515 | 530  | 0.1371        |
+| 0.3521 | 531  | 0.1379        |
+| 0.3528 | 532  | 0.1612        |
+| 0.3534 | 533  | 0.1484        |
+| 0.3541 | 534  | 0.1314        |
+| 0.3548 | 535  | 0.1654        |
+| 0.3554 | 536  | 0.132         |
+| 0.3561 | 537  | 0.1285        |
+| 0.3568 | 538  | 0.1697        |
+| 0.3574 | 539  | 0.1517        |
+| 0.3581 | 540  | 0.1489        |
+| 0.3588 | 541  | 0.1494        |
+| 0.3594 | 542  | 0.1823        |
+| 0.3601 | 543  | 0.1623        |
+| 0.3607 | 544  | 0.1699        |
+| 0.3614 | 545  | 0.1822        |
+| 0.3621 | 546  | 0.1245        |
+| 0.3627 | 547  | 0.1508        |
+| 0.3634 | 548  | 0.1662        |
+| 0.3641 | 549  | 0.1954        |
+| 0.3647 | 550  | 0.1198        |
+| 0.3654 | 551  | 0.1268        |
+| 0.3660 | 552  | 0.1751        |
+| 0.3667 | 553  | 0.1451        |
+| 0.3674 | 554  | 0.1522        |
+| 0.3680 | 555  | 0.1558        |
+| 0.3687 | 556  | 0.1357        |
+| 0.3694 | 557  | 0.1688        |
+| 0.3700 | 558  | 0.1448        |
+| 0.3707 | 559  | 0.1713        |
+| 0.3714 | 560  | 0.1427        |
+| 0.3720 | 561  | 0.1594        |
+| 0.3727 | 562  | 0.1596        |
+| 0.3733 | 563  | 0.1762        |
+| 0.3740 | 564  | 0.1453        |
+| 0.3747 | 565  | 0.1397        |
+| 0.3753 | 566  | 0.1664        |
+| 0.3760 | 567  | 0.1493        |
+| 0.3767 | 568  | 0.1467        |
+| 0.3773 | 569  | 0.1393        |
+| 0.3780 | 570  | 0.1463        |
+| 0.3786 | 571  | 0.1551        |
+| 0.3793 | 572  | 0.1962        |
+| 0.3800 | 573  | 0.1681        |
+| 0.3806 | 574  | 0.1759        |
+| 0.3813 | 575  | 0.1948        |
+| 0.3820 | 576  | 0.1732        |
+| 0.3826 | 577  | 0.1707        |
+| 0.3833 | 578  | 0.1243        |
+| 0.3840 | 579  | 0.1754        |
+| 0.3846 | 580  | 0.1582        |
+| 0.3853 | 581  | 0.1565        |
+| 0.3859 | 582  | 0.148         |
+| 0.3866 | 583  | 0.1528        |
+| 0.3873 | 584  | 0.1478        |
+| 0.3879 | 585  | 0.1363        |
+| 0.3886 | 586  | 0.1578        |
+| 0.3893 | 587  | 0.1648        |
+| 0.3899 | 588  | 0.1619        |
+| 0.3906 | 589  | 0.1471        |
+| 0.3912 | 590  | 0.1552        |
+| 0.3919 | 591  | 0.1432        |
+| 0.3926 | 592  | 0.1418        |
+| 0.3932 | 593  | 0.1765        |
+| 0.3939 | 594  | 0.1712        |
+| 0.3946 | 595  | 0.1697        |
+| 0.3952 | 596  | 0.1545        |
+| 0.3959 | 597  | 0.177         |
+| 0.3966 | 598  | 0.1194        |
+| 0.3972 | 599  | 0.1789        |
+| 0.3979 | 600  | 0.1403        |
+| 0.3985 | 601  | 0.1357        |
+| 0.3992 | 602  | 0.1588        |
+| 0.3999 | 603  | 0.1471        |
+| 0.4005 | 604  | 0.1593        |
+| 0.4012 | 605  | 0.1507        |
+| 0.4019 | 606  | 0.1458        |
+| 0.4025 | 607  | 0.1384        |
+| 0.4032 | 608  | 0.1494        |
+| 0.4038 | 609  | 0.1185        |
+| 0.4045 | 610  | 0.164         |
+| 0.4052 | 611  | 0.1696        |
+| 0.4058 | 612  | 0.1629        |
+| 0.4065 | 613  | 0.1511        |
+| 0.4072 | 614  | 0.1295        |
+| 0.4078 | 615  | 0.1583        |
+| 0.4085 | 616  | 0.1277        |
+| 0.4092 | 617  | 0.1538        |
+| 0.4098 | 618  | 0.162         |
+| 0.4105 | 619  | 0.1394        |
+| 0.4111 | 620  | 0.1504        |
+| 0.4118 | 621  | 0.1511        |
+| 0.4125 | 622  | 0.1783        |
+| 0.4131 | 623  | 0.1285        |
+| 0.4138 | 624  | 0.1371        |
+| 0.4145 | 625  | 0.1655        |
+| 0.4151 | 626  | 0.1374        |
+| 0.4158 | 627  | 0.1299        |
+| 0.4164 | 628  | 0.1567        |
+| 0.4171 | 629  | 0.1436        |
+| 0.4178 | 630  | 0.1519        |
+| 0.4184 | 631  | 0.1228        |
+| 0.4191 | 632  | 0.1318        |
+| 0.4198 | 633  | 0.1523        |
+| 0.4204 | 634  | 0.1436        |
+| 0.4211 | 635  | 0.1596        |
+| 0.4218 | 636  | 0.1582        |
+| 0.4224 | 637  | 0.1529        |
+| 0.4231 | 638  | 0.1487        |
+| 0.4237 | 639  | 0.1086        |
+| 0.4244 | 640  | 0.1371        |
+| 0.4251 | 641  | 0.1579        |
+| 0.4257 | 642  | 0.1484        |
+| 0.4264 | 643  | 0.1621        |
+| 0.4271 | 644  | 0.1618        |
+| 0.4277 | 645  | 0.136         |
+| 0.4284 | 646  | 0.1313        |
+| 0.4290 | 647  | 0.1465        |
+| 0.4297 | 648  | 0.1926        |
+| 0.4304 | 649  | 0.1722        |
+| 0.4310 | 650  | 0.1301        |
+| 0.4317 | 651  | 0.1497        |
+| 0.4324 | 652  | 0.1765        |
+| 0.4330 | 653  | 0.148         |
+| 0.4337 | 654  | 0.1544        |
+| 0.4344 | 655  | 0.1641        |
+| 0.4350 | 656  | 0.142         |
+| 0.4357 | 657  | 0.1528        |
+| 0.4363 | 658  | 0.1589        |
+| 0.4370 | 659  | 0.1318        |
+| 0.4377 | 660  | 0.143         |
+| 0.4383 | 661  | 0.1523        |
+| 0.4390 | 662  | 0.1448        |
+| 0.4397 | 663  | 0.1473        |
+| 0.4403 | 664  | 0.1137        |
+| 0.4410 | 665  | 0.1481        |
+| 0.4416 | 666  | 0.1701        |
+| 0.4423 | 667  | 0.1663        |
+| 0.4430 | 668  | 0.1602        |
+| 0.4436 | 669  | 0.188         |
+| 0.4443 | 670  | 0.1723        |
+| 0.4450 | 671  | 0.183         |
+| 0.4456 | 672  | 0.1696        |
+| 0.4463 | 673  | 0.1291        |
+| 0.4469 | 674  | 0.1377        |
+| 0.4476 | 675  | 0.1779        |
+| 0.4483 | 676  | 0.1614        |
+| 0.4489 | 677  | 0.1361        |
+| 0.4496 | 678  | 0.1553        |
+| 0.4503 | 679  | 0.1487        |
+| 0.4509 | 680  | 0.1495        |
+| 0.4516 | 681  | 0.1445        |
+| 0.4523 | 682  | 0.1394        |
+| 0.4529 | 683  | 0.1329        |
+| 0.4536 | 684  | 0.136         |
+| 0.4542 | 685  | 0.1543        |
+| 0.4549 | 686  | 0.1387        |
+| 0.4556 | 687  | 0.1457        |
+| 0.4562 | 688  | 0.1453        |
+| 0.4569 | 689  | 0.1439        |
+| 0.4576 | 690  | 0.1501        |
+| 0.4582 | 691  | 0.1585        |
+| 0.4589 | 692  | 0.1753        |
+| 0.4595 | 693  | 0.1313        |
+| 0.4602 | 694  | 0.1305        |
+| 0.4609 | 695  | 0.144         |
+| 0.4615 | 696  | 0.1553        |
+| 0.4622 | 697  | 0.1543        |
+| 0.4629 | 698  | 0.1569        |
+| 0.4635 | 699  | 0.1515        |
+| 0.4642 | 700  | 0.1532        |
+| 0.4649 | 701  | 0.161         |
+| 0.4655 | 702  | 0.1229        |
+| 0.4662 | 703  | 0.1695        |
+| 0.4668 | 704  | 0.1503        |
+| 0.4675 | 705  | 0.1529        |
+| 0.4682 | 706  | 0.1465        |
+| 0.4688 | 707  | 0.1927        |
+| 0.4695 | 708  | 0.1549        |
+| 0.4702 | 709  | 0.1487        |
+| 0.4708 | 710  | 0.1425        |
+| 0.4715 | 711  | 0.1569        |
+| 0.4721 | 712  | 0.1455        |
+| 0.4728 | 713  | 0.1556        |
+| 0.4735 | 714  | 0.1441        |
+| 0.4741 | 715  | 0.1449        |
+| 0.4748 | 716  | 0.1752        |
+| 0.4755 | 717  | 0.177         |
+| 0.4761 | 718  | 0.1621        |
+| 0.4768 | 719  | 0.1697        |
+| 0.4775 | 720  | 0.1843        |
+| 0.4781 | 721  | 0.1858        |
+| 0.4788 | 722  | 0.1526        |
+| 0.4794 | 723  | 0.1391        |
+| 0.4801 | 724  | 0.1421        |
+| 0.4808 | 725  | 0.1563        |
+| 0.4814 | 726  | 0.1562        |
+| 0.4821 | 727  | 0.1783        |
+| 0.4828 | 728  | 0.1553        |
+| 0.4834 | 729  | 0.1513        |
+| 0.4841 | 730  | 0.1686        |
+| 0.4847 | 731  | 0.1467        |
+| 0.4854 | 732  | 0.1902        |
+| 0.4861 | 733  | 0.1607        |
+| 0.4867 | 734  | 0.1259        |
+| 0.4874 | 735  | 0.1559        |
+| 0.4881 | 736  | 0.1611        |
+| 0.4887 | 737  | 0.1529        |
+| 0.4894 | 738  | 0.197         |
+| 0.4901 | 739  | 0.124         |
+| 0.4907 | 740  | 0.1382        |
+| 0.4914 | 741  | 0.1277        |
+| 0.4920 | 742  | 0.1247        |
+| 0.4927 | 743  | 0.1399        |
+| 0.4934 | 744  | 0.1676        |
+| 0.4940 | 745  | 0.1403        |
+| 0.4947 | 746  | 0.1258        |
+| 0.4954 | 747  | 0.1515        |
+| 0.4960 | 748  | 0.1464        |
+| 0.4967 | 749  | 0.1598        |
+| 0.4973 | 750  | 0.1587        |
+| 0.4980 | 751  | 0.1852        |
+| 0.4987 | 752  | 0.1101        |
+| 0.4993 | 753  | 0.1484        |
+| 0.5    | 754  | 0.1499        |
+| 0.5007 | 755  | 0.1234        |
+| 0.5013 | 756  | 0.1408        |
+| 0.5020 | 757  | 0.1387        |
+| 0.5027 | 758  | 0.1285        |
+| 0.5033 | 759  | 0.1236        |
+| 0.5040 | 760  | 0.1543        |
+| 0.5046 | 761  | 0.133         |
+| 0.5053 | 762  | 0.132         |
+| 0.5060 | 763  | 0.1376        |
+| 0.5066 | 764  | 0.1332        |
+| 0.5073 | 765  | 0.1588        |
+| 0.5080 | 766  | 0.1195        |
+| 0.5086 | 767  | 0.129         |
+| 0.5093 | 768  | 0.1419        |
+| 0.5099 | 769  | 0.1334        |
+| 0.5106 | 770  | 0.152         |
+| 0.5113 | 771  | 0.1767        |
+| 0.5119 | 772  | 0.1538        |
+| 0.5126 | 773  | 0.1434        |
+| 0.5133 | 774  | 0.1506        |
+| 0.5139 | 775  | 0.1356        |
+| 0.5146 | 776  | 0.1491        |
+| 0.5153 | 777  | 0.1665        |
+| 0.5159 | 778  | 0.1561        |
+| 0.5166 | 779  | 0.1398        |
+| 0.5172 | 780  | 0.1591        |
+| 0.5179 | 781  | 0.1375        |
+| 0.5186 | 782  | 0.1512        |
+| 0.5192 | 783  | 0.1462        |
+| 0.5199 | 784  | 0.1539        |
+| 0.5206 | 785  | 0.154         |
+| 0.5212 | 786  | 0.1378        |
+| 0.5219 | 787  | 0.1341        |
+| 0.5225 | 788  | 0.1888        |
+| 0.5232 | 789  | 0.1413        |
+| 0.5239 | 790  | 0.171         |
+| 0.5245 | 791  | 0.1357        |
+| 0.5252 | 792  | 0.1621        |
+| 0.5259 | 793  | 0.1629        |
+| 0.5265 | 794  | 0.1315        |
+| 0.5272 | 795  | 0.1517        |
+| 0.5279 | 796  | 0.1221        |
+| 0.5285 | 797  | 0.1528        |
+| 0.5292 | 798  | 0.152         |
+| 0.5298 | 799  | 0.1105        |
+| 0.5305 | 800  | 0.1638        |
+| 0.5312 | 801  | 0.1464        |
+| 0.5318 | 802  | 0.1473        |
+| 0.5325 | 803  | 0.1184        |
+| 0.5332 | 804  | 0.1859        |
+| 0.5338 | 805  | 0.141         |
+| 0.5345 | 806  | 0.1408        |
+| 0.5351 | 807  | 0.1136        |
+| 0.5358 | 808  | 0.1531        |
+| 0.5365 | 809  | 0.1398        |
+| 0.5371 | 810  | 0.1681        |
+| 0.5378 | 811  | 0.1521        |
+| 0.5385 | 812  | 0.1484        |
+| 0.5391 | 813  | 0.1545        |
+| 0.5398 | 814  | 0.1768        |
+| 0.5405 | 815  | 0.1471        |
+| 0.5411 | 816  | 0.1413        |
+| 0.5418 | 817  | 0.1349        |
+| 0.5424 | 818  | 0.141         |
+| 0.5431 | 819  | 0.1634        |
+| 0.5438 | 820  | 0.1419        |
+| 0.5444 | 821  | 0.153         |
+| 0.5451 | 822  | 0.166         |
+| 0.5458 | 823  | 0.1491        |
+| 0.5464 | 824  | 0.1363        |
+| 0.5471 | 825  | 0.1667        |
+| 0.5477 | 826  | 0.1605        |
+| 0.5484 | 827  | 0.1481        |
+| 0.5491 | 828  | 0.1731        |
+| 0.5497 | 829  | 0.1626        |
+| 0.5504 | 830  | 0.1628        |
+| 0.5511 | 831  | 0.1554        |
+| 0.5517 | 832  | 0.1213        |
+| 0.5524 | 833  | 0.1461        |
+| 0.5531 | 834  | 0.1787        |
+| 0.5537 | 835  | 0.1714        |
+| 0.5544 | 836  | 0.159         |
+| 0.5550 | 837  | 0.1605        |
+| 0.5557 | 838  | 0.1622        |
+| 0.5564 | 839  | 0.1502        |
+| 0.5570 | 840  | 0.1629        |
+| 0.5577 | 841  | 0.1468        |
+| 0.5584 | 842  | 0.1479        |
+| 0.5590 | 843  | 0.1281        |
+| 0.5597 | 844  | 0.1478        |
+| 0.5603 | 845  | 0.1497        |
+| 0.5610 | 846  | 0.1516        |
+| 0.5617 | 847  | 0.1434        |
+| 0.5623 | 848  | 0.1397        |
+| 0.5630 | 849  | 0.1153        |
+| 0.5637 | 850  | 0.1787        |
+| 0.5643 | 851  | 0.1342        |
+| 0.5650 | 852  | 0.139         |
+| 0.5656 | 853  | 0.142         |
+| 0.5663 | 854  | 0.1438        |
+| 0.5670 | 855  | 0.1596        |
+| 0.5676 | 856  | 0.1263        |
+| 0.5683 | 857  | 0.1506        |
+| 0.5690 | 858  | 0.1338        |
+| 0.5696 | 859  | 0.1481        |
+| 0.5703 | 860  | 0.1599        |
+| 0.5710 | 861  | 0.1516        |
+| 0.5716 | 862  | 0.1305        |
+| 0.5723 | 863  | 0.1355        |
+| 0.5729 | 864  | 0.1408        |
+| 0.5736 | 865  | 0.1712        |
+| 0.5743 | 866  | 0.1473        |
+| 0.5749 | 867  | 0.1337        |
+| 0.5756 | 868  | 0.1336        |
+| 0.5763 | 869  | 0.1501        |
+| 0.5769 | 870  | 0.1387        |
+| 0.5776 | 871  | 0.1618        |
+| 0.5782 | 872  | 0.147         |
+| 0.5789 | 873  | 0.1617        |
+| 0.5796 | 874  | 0.1403        |
+| 0.5802 | 875  | 0.1548        |
+| 0.5809 | 876  | 0.1265        |
+| 0.5816 | 877  | 0.1286        |
+| 0.5822 | 878  | 0.1439        |
+| 0.5829 | 879  | 0.1589        |
+| 0.5836 | 880  | 0.1584        |
+| 0.5842 | 881  | 0.1177        |
+| 0.5849 | 882  | 0.1322        |
+| 0.5855 | 883  | 0.1212        |
+| 0.5862 | 884  | 0.1642        |
+| 0.5869 | 885  | 0.1123        |
+| 0.5875 | 886  | 0.1614        |
+| 0.5882 | 887  | 0.1327        |
+| 0.5889 | 888  | 0.1539        |
+| 0.5895 | 889  | 0.1282        |
+| 0.5902 | 890  | 0.1272        |
+| 0.5908 | 891  | 0.1414        |
+| 0.5915 | 892  | 0.1398        |
+| 0.5922 | 893  | 0.1616        |
+| 0.5928 | 894  | 0.1305        |
+| 0.5935 | 895  | 0.1809        |
+| 0.5942 | 896  | 0.1357        |
+| 0.5948 | 897  | 0.1316        |
+| 0.5955 | 898  | 0.1497        |
+| 0.5962 | 899  | 0.1455        |
+| 0.5968 | 900  | 0.1281        |
+| 0.5975 | 901  | 0.157         |
+| 0.5981 | 902  | 0.1655        |
+| 0.5988 | 903  | 0.1311        |
+| 0.5995 | 904  | 0.1492        |
+| 0.6001 | 905  | 0.1346        |
+| 0.6008 | 906  | 0.1898        |
+| 0.6015 | 907  | 0.159         |
+| 0.6021 | 908  | 0.1285        |
+| 0.6028 | 909  | 0.1632        |
+| 0.6034 | 910  | 0.1367        |
+| 0.6041 | 911  | 0.1353        |
+| 0.6048 | 912  | 0.1255        |
+| 0.6054 | 913  | 0.1766        |
+| 0.6061 | 914  | 0.1434        |
+| 0.6068 | 915  | 0.1213        |
+| 0.6074 | 916  | 0.1439        |
+| 0.6081 | 917  | 0.1422        |
+| 0.6088 | 918  | 0.1753        |
+| 0.6094 | 919  | 0.1475        |
+| 0.6101 | 920  | 0.1362        |
+| 0.6107 | 921  | 0.1596        |
+| 0.6114 | 922  | 0.1202        |
+| 0.6121 | 923  | 0.1161        |
+| 0.6127 | 924  | 0.1589        |
+| 0.6134 | 925  | 0.1559        |
+| 0.6141 | 926  | 0.1407        |
+| 0.6147 | 927  | 0.1308        |
+| 0.6154 | 928  | 0.1643        |
+| 0.6160 | 929  | 0.1427        |
+| 0.6167 | 930  | 0.1409        |
+| 0.6174 | 931  | 0.1291        |
+| 0.6180 | 932  | 0.1336        |
+| 0.6187 | 933  | 0.1631        |
+| 0.6194 | 934  | 0.1472        |
+| 0.6200 | 935  | 0.1397        |
+| 0.6207 | 936  | 0.1407        |
+| 0.6214 | 937  | 0.1336        |
+| 0.6220 | 938  | 0.1456        |
+| 0.6227 | 939  | 0.1073        |
+| 0.6233 | 940  | 0.1426        |
+| 0.6240 | 941  | 0.1459        |
+| 0.6247 | 942  | 0.127         |
+| 0.6253 | 943  | 0.1466        |
+| 0.6260 | 944  | 0.1424        |
+| 0.6267 | 945  | 0.1318        |
+| 0.6273 | 946  | 0.136         |
+| 0.6280 | 947  | 0.1577        |
+| 0.6286 | 948  | 0.1168        |
+| 0.6293 | 949  | 0.1346        |
+| 0.6300 | 950  | 0.1666        |
+| 0.6306 | 951  | 0.1474        |
+| 0.6313 | 952  | 0.1162        |
+| 0.6320 | 953  | 0.12          |
+| 0.6326 | 954  | 0.1148        |
+| 0.6333 | 955  | 0.132         |
+| 0.6340 | 956  | 0.1709        |
+| 0.6346 | 957  | 0.1416        |
+| 0.6353 | 958  | 0.141         |
+| 0.6359 | 959  | 0.1301        |
+| 0.6366 | 960  | 0.1333        |
+| 0.6373 | 961  | 0.1362        |
+| 0.6379 | 962  | 0.1381        |
+| 0.6386 | 963  | 0.1804        |
+| 0.6393 | 964  | 0.1333        |
+| 0.6399 | 965  | 0.1586        |
+| 0.6406 | 966  | 0.1711        |
+| 0.6412 | 967  | 0.1472        |
+| 0.6419 | 968  | 0.1512        |
+| 0.6426 | 969  | 0.1465        |
+| 0.6432 | 970  | 0.1601        |
+| 0.6439 | 971  | 0.1434        |
+| 0.6446 | 972  | 0.1319        |
+| 0.6452 | 973  | 0.1992        |
+| 0.6459 | 974  | 0.1389        |
+| 0.6466 | 975  | 0.1822        |
+| 0.6472 | 976  | 0.1606        |
+| 0.6479 | 977  | 0.1896        |
+| 0.6485 | 978  | 0.136         |
+| 0.6492 | 979  | 0.1368        |
+| 0.6499 | 980  | 0.1367        |
+| 0.6505 | 981  | 0.1278        |
+| 0.6512 | 982  | 0.1473        |
+| 0.6519 | 983  | 0.1482        |
+| 0.6525 | 984  | 0.1461        |
+| 0.6532 | 985  | 0.1822        |
+| 0.6538 | 986  | 0.1436        |
+| 0.6545 | 987  | 0.1549        |
+| 0.6552 | 988  | 0.1194        |
+| 0.6558 | 989  | 0.1082        |
+| 0.6565 | 990  | 0.1398        |
+| 0.6572 | 991  | 0.113         |
+| 0.6578 | 992  | 0.1376        |
+| 0.6585 | 993  | 0.1849        |
+| 0.6592 | 994  | 0.1665        |
+| 0.6598 | 995  | 0.1503        |
+| 0.6605 | 996  | 0.1498        |
+| 0.6611 | 997  | 0.1335        |
+| 0.6618 | 998  | 0.1348        |
+| 0.6625 | 999  | 0.1507        |
+| 0.6631 | 1000 | 0.1366        |
+
+</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--neg-v0-bs320-5e-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:c0e13bbc850fd5575e4d2e3a6087596e3da834c50b63995c242b87f82b7dbf99
+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>"
+}