LLM이 작동하는 방식

docs.scrimba.com

먼저 이름부터. LLM은 large language model(대규모 언어 모델)의 약자입니다: ChatGPT와 같은 도구를 이끄는 AI의 종류로, 프롬프트를 보내면 텍스트를 받아오는 것입니다. 이 장은 실제로 하나가 무엇인지에 대한 실제 그림입니다.

질문을 입력하면 몇 초 후 유창하고 자신감 있는 답변이 나타납니다. 모델이 당신을 이해하고 답변을 찾아본 것처럼 읽힙니다. 그 인상은 유용하며, 또한 중요한 방식으로 잘못되었습니다. 그리고 둘 사이의 간격이 대부분의 초보자 실수의 원인입니다.

이것이 이러한 도구를 사용한 나머지 경력 동안 보상을 받는 장입니다. 모델을 학습시키기 위한 수학을 알 필요는 없습니다. 답변할 때 실제로 무슨 일이 일어나고 있는지에 대한 실제 그림이 필요합니다. 왜냐하면 그 그림이 다른 모든 것을 설명하기 때문입니다: 프롬프팅이 왜 작동하는지, 같은 질문이 왜 다른 답변을 주는지, 모델이 왜 사실을 만들어내는지, 왜 그들이 그들이 하는 비용이 드는지, 그리고 왜 어떤 기능은 사소해 보이는데 어려운지. 이 핸드북의 나중의 모든 것이 여기의 아이디어의 결과입니다.

이 장은 이러한 시스템 아래의 정신 모델입니다: 모델이 무엇인지, 그것이 실행하는 하나의 루프, 그리고 나머지 핸드북을 설명하는 몇 가지 속성. 수학은 없습니다. 모두 블랙박스에 대해 코딩하는 것과 그것이 왜 그렇게 행동하는지 아는 것의 차이입니다.

나중의 모든 기술, 프롬팅, 구조화된 출력, 검색, 에이전트는 당신이 읽으려는 것의 결과입니다. 이 그림을 올바르게 이해하면 나머지는 트릭 모음처럼 느껴지는 것에서 당신이 예측할 수 있는 하나의 기계처럼 느껴지기 시작합니다.

이러한 모델은 구체적이고 반복 가능한 방식으로 실패하며, 이 장은 그 이유입니다. 인터페이스를 제거하면 언어 모델은 한 번에 한 청크씩 텍스트를 예측하는 고정 함수이며, 거의 모든 프로덕션 실패 모드, 비결정성, 비용 폭증, 손실된 컨텍스트, 자신감 있는 잘못된 답변은 그 단일 사실에서 나옵니다.

여기에는 새로운 수학이 없으며, 그것이 포인트입니다: 지속 가능한 공학 이점은 월간 모델이 아니라 메커니즘에 있습니다. 나중의 모든 결정이 나머지는 토대로 읽으십시오.

모델이 실제로 무엇인지

채팅 인터페이스를 제거하면 대규모 언어 모델은 한 가지입니다: 엄청난 수학 함수, **매개변수**라고 불리는 수십억 개의 고정된 숫자 집합(가중치라고도 불림). 그것이 전체 모델입니다. 데이터베이스가 아니고, 검색 엔진도 아니고, 상자 안의 작은 사람도 아닙니다. 텍스트를 가져와서 텍스트를 출력하는 매우 큰 숫자 더미입니다.

이 숫자들은 프로그래머가 입력해서 나온 것이 아닙니다. 그들은 학습 중에 설정되었습니다. 제공자는 모델에 엄청난 양의 텍스트, 책, 코드, 기사, 웹 페이지를 공급했고 수십억 번 간단한 드릴을 실행했습니다: 다음 단어를 숨기고, 모델에게 그것을 예측하도록 요청하고, 잘못 추측할 때마다 그 숫자를 약간 밀어붙이기. 엄청난 규모로 반복하고 숫자는 천천히 텍스트를 잘 예측하는 값으로 정착합니다. 그것이 학습입니다: 예측이 좋아질 때까지 수십억 개의 다이얼 튜닝.

이 두 가지에서 따르며 나중에 만날 많은 행동을 설명합니다. 첫째, 학습은 한 번 일어나고 미리, 그리고 엄청나게 비쌉니다. 모델을 호출할 때쯤이면 숫자는 고정됩니다. 모델은 당신의 대화에서 학습하지 않습니다. 당신이 말하는 것은 매개변수를 변경하지 않습니다. 그것은 기억하고 적응하는 것처럼 느껴지지만, 그것은 소프트웨어 주변의 것이지 모델 자체가 아니며, 컨텍스트 윈도우 섹션에서 어렵게 돌아오는 포인트입니다.

두 번째, 그 안에는 사실 테이블이 없습니다. "지식"은 그 숫자에 구워진 패턴으로 살아있으며, 만들기 과정에서 그 숫자에 기술을 가지고 있는 제빵사가 레시피를 읽지 않는 것처럼. 모델은 정확하고 타당한 텍스트의 모양을 배웠습니다. 이것이 같은 문장에서 유창하고 잘못될 수 있는 이유입니다: 저장된 사실을 선반에서 읽지 않고 좋은 답변의 모양을 재현하고 있습니다.

Juno모델이 실제로 무엇인지 그래서 모델은 텍스트를 텍스트로 변환하는 고정된 거대한 숫자 더미이고, 그 숫자들은 학습 중에 한 번 조정되고 그 다음 고정됩니다. 당신과 채팅하면서 학습하지 않으며, 내부에 정돈된 사실 테이블이 없으며, 패턴이 있습니다. 이것이 확신을 가지고 여전히 틀릴 수 있는 이유이므로 항상 중요한 것을 확인하십시오.

모델은 **순함수**입니다: (가중치, 입력)을 주면 출력을 계산하며, 그 이상 아무것도 하지 않습니다. 가중치는 학습 중에 고정된 수십억 개의 학습된 숫자이며, 입력은 당신이 보내는 텍스트입니다. 함수이기 때문에 같은 설정 아래에서 같은 입력은 매번 같은 기본 점수를 생성합니다. 실행 간에 보는 변동은 점수에서 단어를 선택하는 샘플링 단계에서 나오며, 모델이 생각을 바꾸는 것에서가 아닙니다.

그 함수가 가진 지식은 손실 없이 저장되고, 압축되고 가중치 전체에 한 번에 퍼져 있으며, 검색 가능한 기록으로 파일되지 않습니다. 읽을 수 있는 행이 없고, 편집할 수 있는 셀도 없습니다. 모델이 "아는" 사실은 정말로 가중치가 요청 시 재구성하는 강한 패턴이며, 때때로 약간 잘못 재구성합니다. 사실이 어디 살고 있는지 가리킬 수 없으며, 재학습 없이 한 가지 사실도 패치할 수 없습니다.

실제적인 접근 방식은 모델을 쿼리하는 지식 기반이 아니라 호출하는 고정된 함수로 취급하는 것입니다. 언어 형성, 텍스트 추론, 지시사항 따르기에 의존하세요. 구체적이거나 현재이거나 감사 가능한 것이 필요하면 대신 가중치가 그것을 유지하기를 바라는 대신 입력 자체를 통해 그 정보를 공급하십시오. 그 단일 습관, 사실을 공급하기보다 기대하는 것이 아니라, 자신감 있는 잘못된 답변의 큰 부분을 방지합니다.

Juno모델이 실제로 무엇인지 모델을 (가중치, 입력)의 순함수로 생각하세요: 같은 입력, 같은 설정, 같은 기본 점수, 실행 간 변동은 샘플링에서 나옵니다. 그 지식은 가중치 전체에 손실 없이 압축되어 있으므로 단일 사실을 찾거나 편집할 수 없습니다. 그에 따라 구축하세요: 그것을 호출하는 고정된 함수로 취급하고, 가중치가 그것들을 기억하기를 바라는 대신 입력을 통해 구체적이거나 현재의 사실을 공급하십시오.

배포된 모델은 API 뒤의 고정된 가중치입니다: 수십억 개의 학습된 숫자, 학습 시간에 고정되어, (가중치, 입력)의 순함수를 계산합니다. 그 행동이 실제로 변하는 유일한 시간은 제공자가 다른 모델을 배포할 때입니다.

이것은 날카로운 운영 가장자리를 가집니다. 같은 엔드포인트 아래의 침묵하는 업데이트는 당신의 코드의 한 줄도 변하지 않으면서 출력을 이동할 수 있으므로, 특정 모델 버전을 고정하고, 그 버전을 당신의 계약의 일부로 취급하고, 새로운 버전을 채택하기 전에 evals를 다시 실행하세요. 신뢰를 기반으로 "최신"을 채택하는 것은 작동 시스템이 조용히 회귀하는 방식입니다.

가중치는 압축된 매개변수 메모리이고, 그것은 손실이 많고 감사할 수 없습니다. 버전 간에 모델이 "알고 있는" 것을 diff할 수 없으며, 그것의 사실을 나열할 수 없으며, 주어진 사실이 거기에 있는지 또는 정확한지 증명할 수 없습니다. 따라서 로드를 지탱하는 사실의 정확성을 매개변수 회상에 놓지 마세요. 잘못된 답변이 당신에게 비용이 들면, 당신이 제어하고 인용할 수 있는 소스의 입력에서 사실을 공급하고 모델을 그 소스를 추론하고 추론하는 역할에 유지하세요, 소스가 아닙니다.

의도적으로 가중치를 변경하는 것은 fine-tuning이 하는 것이고, 그것이 무엇을 사는지에 대해 명확한 것이 가치가 있습니다. Fine-tuning은 행동과 형태, 톤, 형식, 작업 습관을 안정적으로 이동하지만, 신뢰할 수 있는 쿼리 가능한 사실 저장소를 제공하지 않습니다. 모델이 응답하는 방법을 형성하기 위해 그것에 도달하고, 당신이 신뢰해야 하는 지식을 설치하기 위해서가 아닙니다. 입력에서 사실을 유지하고, 가중치에서 스타일을 유지하고, 당신은 둘 중 하나에서 놀라지 않을 것입니다.

Juno모델이 실제로 무엇인지 가중치는 고정되어 있으므로 행동은 제공자가 다른 모델을 배포할 때만 움직입니다: 버전을 고정하고, 그것을 당신의 계약의 일부로 만들고, 업그레이드하기 전에 evals를 다시 실행하거나 침묵하는 교환이 당신이 잠든 동안 당신을 회귀시킬 것입니다. 매개변수 메모리는 손실이 많고 감사할 수 없습니다; 그것이 알고 있는 것을 diff할 수 없으므로 당신이 제어하는 소스의 입력에서 로드를 지탱하는 사실을 유지하고, 회상에서 아닙니다. 그리고 fine-tuning은 행동과 형태를 이동하고, 신뢰할 수 있는 사실 저장소는 아니므로, 모델이 응답하는 방법에 사용하고, 알아야 할 것에 대해서는 아닙니다.

다음 토큰 예측

그 숫자 더미를 제자리에 두고, 모델은 정확히 하나의 일을 합니다: 반복해서 다음 텍스트 청크를 예측합니다.

느린 움직임에서 루프입니다. 당신은 그것에 텍스트를 줍니다. 그것은 모든 그 매개변수를 통해 텍스트를 실행하고 가능한 모든 다음 청크의 확률, 한 번에 수만 개의 옵션을 생성합니다. "프랑스의 수도는" 이후에, "Paris" 청크는 97% 점수를 얻을 수 있으며, "a"는 1% 점수, 그 외 모두 거의 아무것도 아닙니다.

모델은 그 다음 한 청크를 선택하고, 텍스트에 추가하고, 다음을 선택하기 위해 전체 것을 다시 실행합니다. 답변이 완료될 때까지 반복합니다.

그것이 전체 엔진입니다. 당신이 단일 생각으로 읽은 답변은 한 번에 한 청크씩 구성되었으며, 각 청크는 가능성의 새로운 순위에서 선택되고, 문장이 어디로 가는지에 대한 계획이 없으며, "다음이 가능한 것"을 초과합니다. 당신이 사용할 모든 기능, 채팅, 코드, 번역, 도구 사용, 추론은 기본에서 실행되는 이 같은 루프입니다.

다음 단어를 제안하는 전화 키보드는 축소 규모의 같은 아이디어입니다. 차이점은 추측 뒤의 수십억 개의 매개변수입니다. 충분한 텍스트에 학습하면, "다음의 가장 가능한 청크가 무엇인가"가 작동 코드를 쓰고 명확한 설명을 제공하기에 충분히 좋아 나타납니다. 그러나 기본 이동은 절대 변하지 않습니다: 그것은 예측이며, 이해가 아니며, 저장된 답변을 찾지 않습니다.

Juno다음 토큰 예측 전체 엔진은 하나의 작은 루프입니다: 지금까지 텍스트를 읽고, 가능한 모든 다음 청크를 점수 매기고, 하나를 선택하고, 답변이 완료될 때까지 다시 이동합니다. 모델은 다음에 가능한 것을 초과하여 문장을 계획하지 않으므로, 단일 생각으로 읽은 답변은 실제로 한 번에 한 청크씩 구성되었습니다. 그것은 예측이며, 이해가 아니며, 저장된 답변을 찾지 않습니다.

모델은 한 가지를 반복합니다: 각 단계에서 지금까지의 모든 텍스트를 읽고 token(토큰은 텍스트 청크이며, 종종 단어의 일부)의 어휘 내 모든 것에 대한 점수를 출력합니다, 한 번에 수만 개. 이 점수는 확률 분포가 되고, 모델은 그것에서 하나의 토큰을 샘플링합니다. 그 다음 그것은 텍스트에 그 토큰을 추가하고 다음을 선택하기 위해 전체 것을 다시 실행합니다. "프랑스의 수도는" 이후에, "Paris"는 거의 모든 확률을 보유할 수 있으며 다른 것은 거의 아무것도 없습니다.

이 피드백은 **autoregressive**라고 불리는 이유입니다: 각 새 토큰은 지금까지의 모든 텍스트에 따라 달라지며, 이 차례에서 이미 작성된 토큰을 포함합니다. 전역 계획이 없고 수정할 초안이 없습니다. 모델은 한 번에 한 토큰을 커밋하고, 토큰을 돌려놓을 수 없기 때문에, 코너에 자신을 칠할 수 있습니다: 자신감 있는 초기 단어는 나머지 문장을 그 다음 완료해야 하는 어색한 경로로 강제할 수 있습니다.

그 단일 사실은 실제로 실제로 사용할 몇 가지를 설명합니다. 모델이 최종 답변 전에 그 추론을 적어내도록 하는 것은 도움이 됩니다. 왜냐하면 더 많은 토큰이 답변에 커밋하기 전에 문제에 소비하는 더 많은 단계와 더 많은 계산을 의미하기 때문입니다. 출력 구조는 엄격하게 왼쪽에서 오른쪽으로 결정되므로, 응답의 모양은 진행되면서 설정되고, 미리 계획되지 않습니다. 그리고 같은 루프가 tool use를 드라이브합니다: 모델은 호출을 형성하는 토큰을 예측하고, 당신은 그것을 실행하고, 결과는 다음 예측을 위해 더 많은 텍스트로 피드백됩니다.

Juno다음 토큰 예측 각 단계에서 모델은 어휘의 모든 토큰을 점수 매기고, 하나를 샘플링하고, 다시 피드백합니다: 그 피드백 루프는 autoregressive가 의미하는 것입니다. 계획이 없고 실행 취소가 없으므로, 그것은 한 번에 한 토큰을 커밋하고 코너에 자신을 칠할 수 있습니다. 이것이 답변 전에 추론을 작성하는 것이 도움이 되는 이유이고, tool use가 같은 루프인 이유입니다.

생성은 구성에 의해 순차적입니다: 모델은 하나의 토큰(텍스트 청크)을 생성하고, 다시 피드백하고, 다음을 예측하므로, 각 출력 토큰은 네트워크를 통한 별개의 포워드 패스입니다. 입력을 읽는 것은 상대적으로 저렴하며, 한 번에 처리됩니다; 느리고 비싼 부분은 모델이 쓰는 것입니다. 지연 시간과 비용은 입력 길이가 아니라 출력 길이로 확장합니다. 실제 레버는 그것에서 나옵니다: 출력을 짧게 유지하고, 사용자가 전체 답변을 기다리는 대신 진행 상황을 보도록 토큰을 스트림하고, 버릴 장황한 형식에 대해 비용을 지불하지 마세요.

다른 결과는 정확성입니다. 전역 계획이 없기 때문에, 단일 패스는 자체 수정이 아닙니다: 모델은 왼쪽에서 오른쪽으로 커밋하고 토큰이 나온 후 수정할 수 없습니다. 이것이 정확하게 해야 하는 모든 것이 검증이나 첫 번째 초안의 두 번째 패스를 원하는 이유이고, 그 이유는 모델이 그 답변 전에 그 추론을 작성하는 경향이 있는 이유입니다. 당신은 그것이 더 많은 단계를 커밋할 수 있도록 사는 것입니다. 첫 번째 생성을 초안으로 취급하세요, 판정이 아닙니다.

장비를 원하는 한 가지 레버: 많은 설정은 토큰 당 확률(logprobs, 모델의 각 토큰에 대한 자신감 점수를 선택함)을 노출합니다. 당신은 그것들을 읽어서 낮은 자신감 범위를 플래그하거나, 모델이 불안해했던 답변을 게이트하거나, 불확실한 경우를 두 번째 패스나 인간으로 라우팅할 수 있습니다. 그것은 당신이 이미 가진 저렴한 신호이고, 그것은 "모델이 여기에서 잘못될 수 있습니다"를 당신이 추측하기보다 프로그래밍 방식으로 작동할 수 있는 것으로 변환합니다.

Juno다음 토큰 예측 모든 출력 토큰은 자신의 포워드 패스이므로 비용과 지연 시간은 입력이 아니라 출력 길이를 추적합니다: 답변을 짧게 유지하고, 스트림하고, 버릴 형식에 대해 비용을 지불하는 것을 중단합니다. 계획이 없고 실행 취소가 없으므로, 한 패스는 자체 수정이 아닙니다; 첫 번째 생성을 초안으로 취급하고 정확해야 하는 모든 것에 대해 검증 패스를 추가합니다. logprobs당 토큰을 읽을 수 있다면, 그것을 사용하여 모델이 가장 확신하지 못한 범위를 플래그하거나 라우팅하세요, 그것은 당신이 이미 가진 자신감이고 거의 사용하지 않습니다.

무작위성 다이얼

모델이 항상 단일 최고 점수 청크를 잡았다면, 같은 프롬프트에 같은 답변을 줄 것이고, 그 답변은 종종 평평하고 반복적일 것입니다. 따라서 대부분의 시간에 선택은 약간의 무작위성을 가지고 있습니다: 그것은 보통 높은 확률 청크를 가지고 있지만, 항상 맨 위가 아닙니다. 이것이 같은 질문을 두 번 묻고 두 개의 다른 답변을 얻는 이유입니다. 그것은 시스템이 의도한 대로 작동하는 것이지, 결함이 아닙니다.

당신은 **temperature**라고 불리는 설정을 통해 얼마나 많은 무작위성이 있는지 제어합니다, 당신은 코드에서 모델 호출 장에서 모델을 호출할 때 설정합니다. 직관은 지금 가질 가치가 있습니다. 낮은 온도에서 모델은 최고의 선택에 가깝게 유지합니다: 집중적이고, 일관적이고, 예측 가능하며, 이것이 인보이스에서 숫자를 끌어내거나 텍스트를 범주로 정렬하려는 것입니다. 더 높은 온도에서 더 낮은 확률 청크가 더 자주 선택됩니다: 더 다양하고 창의적이며, 잘못된 곳으로 방황할 가능성이 더 높습니다. 브레인스토밍과 창작 글쓰기가 더 높은 끝을 원합니다; 올바른 답변을 가진 모든 것은 더 낮은 끝을 원합니다.

따라서 단일 다이얼은 모델을 "신중하고 반복 가능한" 과 "놀랍고 창의적인" 사이에서 이동합니다. 온도가 변경되는 방법에 관계없이 동일한 예측 루프입니다; 온도는 가장 안전한 추측을 넘어선 모델 도달이 얼마나 대담한지만 변경합니다.

Juno무작위성 다이얼 온도는 당신의 무작위성 다이얼입니다. 올바른 답변이 있는 작업을 위해 낮게 설정하면, 집중적이고 반복 가능한 답변을 얻습니다. 브레인스토밍과 창의적인 작업을 위해 높게 설정하면, 잘못된 곳으로 방황할 가능성이 높은 변동이 많습니다. 같은 예측 루프, 더 대담하거나 더 안전한 도달만.

모델이 다음 청크를 선택하기 전에, 모든 후보에 대한 확률이 있습니다. 온도는 모델이 그것에서 샘플링하기 전에 그 분포를 재구성합니다. 낮은 온도는 단일 가장 가능한 토큰을 향한 분포를 샤프하게 합니다(항상 최고의 선택에 더 가깝습니다), 그래서 출력은 집중되고 반복 가능합니다. 높은 온도는 그것을 평탄화하고, 덜 가능한 토큰이 실제 기회를 가지므로, 출력은 더 다양하고 더 가능성이 높으며 잘못된 곳으로 표류합니다. 이것이 같은 프롬프트가 다른 답변을 반환할 수 있는 이유입니다: 그려진 것이 일어나고 있으며, 온도는 확률이 얼마나 왜곡되는지를 설정합니다.

온도가 유일한 노브가 아닙니다. Top-p(확률이 p까지 추가되는 가장 작은 토큰 집합에서만 샘플)와 top-k(가장 가능성이 높은 k개의 토큰만)는 샘플링 전에 후보 풀을 자릅니다. 온도의 영향과 겹치므로, 그것을 3개의 독립적인 것이 아니라 하나의 무작위성 설정으로 생각하는 것이 도움이 됩니다.

실제적인 접근 방식은 무엇이든 기본적으로 배송되는 것을 신뢰하는 대신 작업당 명시적으로 온도를 설정하는 것입니다. 추출, 분류, 그리고 당신이 나중에 구문 분석할 구조화된 출력을 내보내는 모든 것에 대해 낮게 이동합니다; 다양성이 포인트인 관념화 및 초안 작성을 위해 더 높게 이동합니다. 상호 작용을 시청하세요: 높은 온도를 1.0의 top-p와 쌓으면 전체 꼬리를 플레이에 두어 신뢰할 수 있는 파싱 가능한 결과가 필요할 때 당신에게 대항합니다.

Juno무작위성 다이얼 온도는 샘플링 전에 확률 분포를 재구성합니다: 낮은 집중된 출력을 위해 최고의 토큰을 향해 날카롭게 하고, 다양성을 위해 높게 평탄화합니다. temperature, top_p, top_k를 3개가 아니라 하나의 무작위성 설정으로 취급하세요. 작업당 설정합니다: 추출, 분류, 구조화된 출력에 대해 낮음; 관념화에 대해 더 높음. 파싱 가능한 결과가 필요할 때 높은 온도를 top_p 1과 쌓지 마세요.

온도는 샘플링 전에 점수 분포를 확장하고, 유혹하는 지름길은 그것을 0으로 설정하고 출력이 결정론적이라고 부르는 것입니다. 그것은 가깝지만, 보증이 아닙니다. 부동 소수점 수학, 서버 측 배치, 그리고 큰 모델 내 라우팅은 모두 0에서도 작은 비결정성을 도입합니다. 따라서 반복된 프롬프트에 대해 바이트 동일한 출력을 가정하는 정확한 일치 캐싱이나 정확한 일치 테스트를 구축하지 마세요; 그 가정은 간헐적으로 실패하고, 간헐적인 실패는 추적하기 비싼 종류입니다.

이것은 샘플된 행동을 테스트하는 방식을 형성합니다. 단일 실행은 stochastic 시스템(실행에서 실행으로 출력이 다양한 것)에 대해 거의 아무것도 알려주지 않으므로, 프롬프트를 여러 번 실행하고 출력 분포를 보면서 평가하세요: 얼마나 자주 사양에 착지하는지, 분산이 얼마나 넓은지, 꼬리가 어디로 잘못되는지. 그것은 evals이 하는 일이고, 그들은 하나의 운 좋은 통과가 아니라 확산을 보기에 충분한 샘플을 원합니다.

온도, top-p(누적 p에 도달하는 토큰의 가장 작은 집합에서만 샘플) 그리고 top-k(가장 가능성이 높은 k개의 토큰만 유지)를 당신이 반사적으로 설정하는 3개의 다이얼이 아니라 함께 튜닝하는 하나의 샘플링 예산으로 취급하세요. 여전히 작업에 대한 허용 가능한 다양성을 제공하는 가장 낮은 무작위성을 선택하세요: 모두 3개를 타이트하게 조이는 것은 출력을 반복적이고 취약한 것으로 붕괴시킬 수 있는 반면, 모두 열어두는 것은 당신이 검증해야 하는 분산을 당신에게 제공합니다. 비용은 양쪽에서 실제이므로, 의도적으로 사용하세요.

Juno무작위성 다이얼 온도 0은 거의 결정론적이고, 보증이 아닙니다: 부동 소수점, 배치, 내부 라우팅은 비결정성을 누출하므로 정확한 일치 캐싱과 정확한 일치 테스트를 건너뛰세요. 샘플된 행동을 여러 실행으로 평가하고 분포를 읽으세요, 하나의 통과가 아닙니다; 그것은 당신의 evals가 위해 있는 것입니다. temperature, top_p, top_k를 하나의 샘플링 예산으로 튜닝하고, 여전히 허용 가능한 다양성을 제공하는 가장 낮은 무작위성을 선택하세요.

토큰

모델이 예측하는 "청크"는 이름이 있습니다: tokens(토큰). 토큰은 텍스트 조각이며, 종종 전체 단어이고, 때때로 하나의 일부입니다. 일반적인 단어는 보통 단일 토큰이고, 길거나 드문 단어는 여러 개로 분할됩니다.

"tokenization"  ->  "token" + "ization"
"unbelievable"  ->  "un" + "believ" + "able"
"cat"           ->  "cat"

전체 단어나 단일 문자를 사용하는 대신 이 이상한 조각으로 텍스트를 자르는 이유는 무엇입니까? 그것은 절충안입니다. 단일 문자는 모든 시퀀스를 엄청나게 만들 것이고, 길이는 모델이 계산해야 하는 것입니다. 전체 단어는 수백만 개의 항목의 어휘를 필요로 할 것이고 여전히 누군가가 단어를 발명하거나 오타를 낼 때마다 깨질 것입니다. 토큰은 중간 경로입니다: 함께 스냅하여 모델이 본 적이 없는 단어를 포함하여 모든 것을 철자할 수 있는 일반적인 조각의 고정된 어휘는 수만 개입니다.

여기 사람들을 놀라게 하는 후드 아래의 결과입니다. 모델은 절대 편지를 보지 않습니다. 그것은 토큰을 봅니다, 그 청크에 대한 정말로 ID 번호입니다. 따라서 우리에게 쉬워 보이는 작업은 그것에 어려울 수 있습니다: 단어의 문자 세기, 문자열 역순, "딸기"가 3개의 r을 가지고 있다는 것을 알아차리기.

그것은 어두운 것이 아닙니다. 그것은 개별 문자를 전혀 인지하지 않으며, 완성된 빵에서 밀가루의 개별 곡립의 맛을 낼 수 없는 방식입니다. 모델이 철자나 문자 세기 작업에서 헛돌 때, 이것이 이유이고, 수정은 보통 대신 평범한 코드에서 그 부분을 하는 것입니다.

토큰은 또한 당신이 지속적으로 신경 쓸 두 가지의 단위입니다:

• 돈: 제공자는 토큰당 청구합니다, 당신이 보내는 토큰과 모델이 작성하는 토큰 모두, 그래서 길게 문서를 입력하고 길게 답변 출력은 모두 더 비쌉니다. 영어에 대한 대략적인 게이지는 토큰당 약 4개의 문자이거나 매 75개 단어마다 100개의 토큰; 코드 및 기타 언어는 종종 더 많은 토큰으로 분할되며, 그것은 부분적으로 그들이 더 많이 비용이 왜 들 수 있는지입니다. 코드에서 모델 호출을 시작할 때 당신은 이것을 직접 만날 것입니다.
• 제한: 모델이 한 번에 처리할 수 있는 토큰의 상한이 있으며, 다음 섹션입니다.

Juno토큰 토큰은 보통 단어나 그 일부인 텍스트 청크이고, 모델은 그 청크를 문자가 아닌 ID 번호로 읽습니다. 이것이 세기나 철자에서 헛돌 수 있는 이유이므로, 그 일을 평범한 코드에 맡기세요. 그리고 당신은 양쪽 방법에서 토큰 당 비용을 지불하고 한 번에 맞을 수 있는 한계가 있기 때문에, 더 적은 토큰은 더 적은 비용과 더 많은 방 의미합니다.

모델은 tokens를 예측합니다, 종종 전체 단어이고 때때로 조각인 텍스트 조각. 분할을 수행하는 조각은 **tokenizer**이고, 그것은 가장 일반적인 문자 쌍을 반복적으로 병합할 때까지 구성된 학습된 어휘에서 작동합니다. 당신은 고정된 수만 개의 조각 집합(보통 byte-pair encoding, BPE라고 불리는 방식)을 가집니다. 이 역사가 정상적인 단어가 단일 토큰으로 끝나는 이유이고 드문 것들은 부분으로 조각화됩니다: 일반적인 패턴은 학습 중에 병합되었고, 드물지 않은 것들은 절대 그렇지 않았습니다.

이것에서 두 가지 실제적인 사실이 나옵니다. 첫 번째, 모델은 절대 문자를 처리하지 않으며 오직 토큰 ID만 처리합니다, 그래서 어떤 문자 수준 작업(문자 세기, 문자열 역순, 정확한 위치에서 슬라이싱)은 프롬프트 내에서 흔들리고 당신의 코드에서 신뢰할 수 있습니다. 그 일을 코드로 밀어붙이고 모델을 언어 부분을 하도록 하세요. 두 번째, tokenization은 모델 특정이므로, 토큰 수는 휴대용이 아닙니다. 같은 문장은 다른 토큰라이저에서 다른 수의 토큰이 들 수 있으며, 이것은 당신이 비용 예산을 하거나 콘텐츠를 윈도우에 맞출 때 중요합니다.

구축하기 위한 핵심: 문자 길이에서 토큰 수를 안구 측정하지 마세요. 모델이 사용하는 실제 토큰라이저로 세세요, 당신이 청구되는 그리고 제한되는 수입니다. 코드에서 모델 호출을 시작할 때 당신은 모든 이것을 구체적으로 만나며, 당신이 보내는 수 더하기 당신이 받는 수가 청구서입니다.

Juno토큰 토큰라이저는 학습된 어휘(BPE)를 사용하여 텍스트를 분할합니다, 이것이 일반적인 단어가 한 토큰이고 드문 것들이 조각화되는 이유입니다. 토큰화는 모델 특정이므로, 모델이 사용하는 모델의 자신의 토큰라이저로 계산하기보다 문자에서 추측합니다. 그리고 문자 수준 일(세기, 역순, 정확한 슬라이싱)을 코드에 유지하고, 프롬프트에 아닙니다.

토큰은 당신이 배송하는 모든 것의 미터입니다. token은 토큰라이저의 학습된 어휘의 텍스트 조각이고, 토큰 당 청구 더하기 고정된 컨텍스트 상한은 당신의 비용과 당신의 디자인을 형성하는 두 수입니다. 평문 영어 산문을 위한 편안한 네 문자 당 토큰 규칙은 프로덕션이 사는 정확히 곳에서 떨어집니다: 코드, JSON, 깊게 중첩된 형식, 그리고 비라틴 스크립트는 모두 휴리스틱이 예측하는 것보다 훨씬 더 많은 토큰으로 조각화됩니다. 실제 토큰라이저로 예산을 하고, 게이지가 아니고, 또는 당신의 비용 그리고 용량 추정치는 당신이 실제로 보내는 페이로드에 정확히 잘못됩니다.

조각화는 균등하게 분포하지 않으며, 그것은 규모가 공정성 그리고 비용 문제입니다. 같은 의미는 비라틴 언어에서 영어 버전의 토큰의 몇 배로 들 수 있으므로, 같은 기능은 일부 사용자에게 다른 것보다 조용히 더 비싸고 느립니다. 누구에게든 평면 가격 또는 고정된 지연을 약속하기 전에 언어 당 측정 가치.

필드에서 두 가지 더 많은 습관. 형식은 지출입니다: 공백, 장황한 구분 기호, 장식 마크다운은 모두 토큰을 제로 추가 의미로 비용합니다, 그래서 당신이 피드하는 구조를 모델에 컴팩트 유지하고, 당신의 코드가 나중에 표현을 추가하게 하세요. 그리고 깨끗하고 정상 텍스트를 피드하세요, 왜냐하면 드문 또는 잘못된 토큰(mojibake, 방황하는 제어 문자, 이상한 인코딩)은 어휘의 박하게 학습된 모서리에 앉고 이상한 출력을 트리거할 수 있기 때문입니다. 그것은 이국적이 아닙니다; 그것은 당신이 신뢰하는 토큰 예산 그리고 송장에서 당신을 놀라게하는 것 사이의 차이입니다.

Juno토큰 네 문자 당 토큰 규칙은 코드, JSON, 비라틴 스크립트에서 깨집니다, 당신의 실제 트래픽이 사는 곳입니다, 그래서 실제 토큰라이저로 예산을 합니다. 비라틴 언어는 같은 의미에 대해 토큰의 몇 배로 들 수 있습니다, 실제 비용 그리고 공정 간격 언어당 측정 가치. 스트립 장식 형식을 토큰을 저장하고, 피드 깨끗한 텍스트 그래서 드물거나 잘못된 토큰은 당신이 이상한 행동을 사지 않습니다.

컨텍스트 윈도우

context window(컨텍스트 윈도우)는 모델이 한 번에 가져올 수 있는 텍스트 양이며, 토큰으로 측정됩니다. 모델의 책상 크기로 생각하세요. 단일 요청과 관련된 모든 것이 한 번에 그 책상에 맞아야 합니다: 당신의 지시사항, 지금까지의 대화, 당신이 붙여넣은 모든 문서, 그리고 모델이 작성하는 답변.

왜 모두 한계가 있나요? 예측이 어떻게 작동하는지에서 옵니다. 다음 토큰을 선택하려면, 모델은 입력의 모든 토큰이 다른 모든 토큰과 어떻게 관련되어 있는지를 비교합니다. 그래서 그것은 "그것"이 3문장 뒤의 고양이를 참조한다는 것을 말할 수 있습니다. 그 모든 대 모든 비교가 모델이 통로 전체의 의미를 추적하도록 허용하는 것이고, 그것은 또한 긴 입력을 처리하는 것을 비싸게 만드는 것입니다. 제공자는 상한, 컨텍스트 윈도우를 설정하여 각 요청을 관리할 수 있게 유지합니다.

책상이 가득 찼을 때, 무언가는 내려와야 합니다. 대화가 오래되어 윈도우를 초과하면, 초기 부분은 떨어지고 모델은 더 이상 그것들을 볼 수 없습니다. 이것이 긴 채팅이 당신이 시작에서 말한 것을 "잊게" 보이는 이유입니다. 어떤 인간 감각에서 그것은 잊지 않았습니다; 토큰은 책상 밖입니다. 그것은 또한 모델이 그것이 책상에 있는 것의 시작과 끝에 가장 가깝게 주의를 기울이는 경향이 있고 중간에 묻힌 것을 추적할 수 있다는 것을 아는 데 도움이 됩니다, 그래서 당신이 중요한 텍스트를 놓는 곳이 중요합니다. 윈도우를 채울 때.

이제 거의 모든 초보자를 잡는 포인트이고, 이것은 나머지보다 더 중요합니다. 모델은 별도의 요청 사이의 기억이 없습니다. 그것의 숫자는 고정되어 있다는 것을 기억하세요. 각 호출은 빈 책상으로 시작합니다. 모델은 당신의 마지막 질문, 당신의 이름, 또는 분 전의 아무 것도 기억하지 않습니다.

채팅 앱은 오직 앱이 모든 새 메시지로 전체 역사를 조용히 다시 보내기 때문에 하나의 흐르는 대화처럼 느껴집니다. 연속성은 모델이 가진 것이 아니라 모델 주변의 소프트웨어가 구축하는 것입니다.

그 단일 사실은 여기서 모든 것을 구축하는 방식을 형성합니다. 모델이 뭔가를 알기를 원하면, 당신은 그 요청에서 책상에 그것을 놓아야 합니다: 지금까지의 대화, 사용자의 세부 정보, 관련 문서, 모두, 매번. 이 핸드북의 큰 부분은 정말로 잘 그 한 가지를 하는 것에 대해입니다, 올바른 텍스트를 책상에 얻기.

Juno컨텍스트 윈도우 컨텍스트 윈도우는 모델의 책상입니다: 모든 요청이 그것에 맞아야 하고, 오버플로우할 때 가장 오래된 텍스트는 떨어집니다. 모델은 호출 사이 기억을 유지하지 않으므로, 앱은 연속적인 채팅을 가짜로 보내기 위해 매번 전체 역사를 다시 보냅니다. 당신의 일은 여기서 올바른 텍스트를 모든 단일 요청에서 그 책상으로 얻는 것입니다.

컨텍스트 윈도우를 단일 요청이 소비하는 고정된 토큰 예산으로 생각하세요, 당신의 지시사항, 실행 대화, 붙여넣은 문서, 그리고 생성되는 답변을 다룹니다. 윈도우는 모델이 입력을 읽는 방식 때문에 존재합니다: **attention**이라는 메커니즘은 모든 토큰을 다른 모든 토큰에 대해 비교하여 무엇이 무엇과 관련되어 있는지를 계산합니다. 그 비교가 "그것"을 그것이 가리키는 명사로 해결할 수 있게 하는 것이며, 그것의 비용은 대략 입력 길이의 제곱으로 증가합니다. 토큰을 두 배로 하고 당신은 일의 두 배 이상을 합니다, 긴 입력이 느리고 비용을 실행하는 이유입니다.

윈도우 내에 맞기는 모델이 모두 사용하는 것과 같지 않습니다. 잘 문서화된 효과가 **lost in the middle**입니다: 모델은 입력의 시작과 끝에 가장 안정적으로 참여하고 중심에 주차된 자료를 건너뛸 수 있습니다. 그래서 당신의 가장 중요한 지시사항 그리고 데이터를 프롬프트의 맨 위 또는 맨 아래 가까이에 배치합니다, 붙여넣은 텍스트의 벽에 묻혀 있지 않습니다.

이것의 다른 반입니다 기억이고, 핵심 사실은 모델이 **stateless**입니다: 그것은 별도의 요청 사이 아무것도 기억하지 않습니다. 각 호출은 빈 윈도우로 시작하므로, 모델이 지금까지의 대화를 알 유일한 방법은 당신이 매번 그것을 다시 보낼 때입니다. 그것을 다시 보내는 것 그리고 그 역사를 형성하는 것은 모델이 아니라 당신의 일입니다. 채팅이 윈도우를 지나 성장하면서, 오래된 턴을 잘라내거나 짧은 요약으로 대체하여 자신을 관리하세요, 그래서 당신이 유지하는 토큰이 여전히 중요한 것입니다.

이것은 이러한 모델 구축의 중심에 컨텍스트 구성을 놓습니다. 윈도우에 무엇이 들어가는지, 어떤 순서에서, 그리고 전에 온 것을 어떻게 압축하는지를 결정하는 것은 대부분의 일이며, prompting은 당신이 그것을 의도적으로 형성하는 방법을 배우는 곳입니다.

Juno컨텍스트 윈도우 윈도우는 지시사항, 역사, 문서, 그리고 답변을 다루는 토큰 예산입니다; 주의는 긴 입력이 대략 그들의 길이의 제곱으로 비용이 들도록 합니다. 모델은 중간 손실 영향을 겪습니다, 그래서 중요한 것을 시작 또는 끝 근처에 놓습니다. 모델은 stateless이므로, 대화 역사를 다시 보내고 자르는 것은 당신의 것입니다, 모든 호출.

컨텍스트 윈도우를 목표가 아니라 상한으로 취급하세요. 그것은 단일 요청이 소비하는 토큰 예산이고, 당신의 지시사항, 실행 역사, 검색된 문서, 그리고 출력을 걸칩니다.

당신이 그것에 놓는 모든 토큰이 비용과 지연 시간이 들고, attention 단계 때문에(모든 대 모든 토큰 비교 모델이 입력을 읽기 위해 실행) 대략 길이의 제곱으로 확장합니다. 더 나쁜 것, 효과적인 회상이 당신이 제한에 도달하기 전에 저하됩니다: lost in the middle 효과는 중심에 묻힌 자료의 정확성이 기술적으로 맞더라도 떨어진다는 것을 의미합니다. 따라서 모든 것을 버리지 않고 컨텍스트를 큐레이트하고, 소스 데이터가 클 때, RAG를 가지고 관련된 조각만 검색하세요. 전체 말뭉치를 붙이지 말고.

순서는 세부 정보가 아니라 레버입니다. 제공자는 **prompt caching**를 통해 변하지 않은 접두사에 대한 계산을 재사용할 수 있으며, 여기서 캐시된 내부 상태는 KV cache입니다, 모델이 이미 읽은 토큰에 대해 저장한 일입니다. 안정적인 콘텐츠 먼저(시스템 지시사항, 고정 참조 자료)를 놓고 변수 콘텐츠 마지막, 그리고 반복된 호출은 프롬프트의 앞면이 캐시에서 제공되기 때문에 더 저렴하고 빠릅니다. 그 접두사를 부주의하게 재순서하고 당신은 캐시를 무효화하고 다시 전체 가격을 지불합니다.

턴 전체 메모리는 모델이 가진 기능이 아닙니다; 그것은 당신이 하는 엔지니어링 선택이며, 각 옵션은 자신의 방식으로 실패합니다:

• 평문 윈도우 추출, 가장 최근 턴 유지는 저렴하지만 조용히 초기 사실을 떨어뜨립니다 사용자는 여전히 당신이 알기를 기대합니다.
• 요약 더 적은 토큰에서 더 많은 역사를 유지하지만 세부 정보를 손실하고 조용히 자신의 오류를 인코딩할 수 있습니다.
• 검색 오직 관련된 것을 다시 가져오지만, 완전히 당신의 인덱스가 올바른 조각을 반환하는 것에 따라 달립니다.

사용 케이스당 선택하고, 당신이 선택한 어느 것이든 결국 잘못된 것을 표면할 것이라고 가정합니다; 그것을 신뢰하기 보다 그것을 도구로 삼으세요.

Juno컨텍스트 윈도우 윈도우는 목표가 아니라 상한입니다: 비용 그리고 지연 시간은 모든 토큰으로 올라가고 회상은 제한에 도달하기 전에 손상되므로, 큐레이트하고 큰 것에 대해 검색에 기대세요. 안정적인 콘텐츠 먼저, 변수 마지막, 그래서 프롬프트 캐싱(KV cache)은 실제로 보상을 합니다. 교차 턴 기억은 윈도우, 요약, 그리고 검색 사이의 당신의 디자인 선택이고, 나는 모두 삼, 그래서 당신이 선택하는 것을 도구로 삼으세요.

모델이 알지 못하는 것

모델의 모든 지식이 학습 중에 구워졌으므로, 그것은 학습 데이터에 있었던 것만 알며, 그 데이터는 과거의 어떤 cutoff 지점까지 수집되었습니다. 두 한계가 바로 이것에서 나옵니다.

첫째, 그것은 cutoff 이후에 일어난 무언가를 알지 못합니다. 지난 주의 뉴스 또는 이번 달에 나온 라이브러리에 대해 묻고 그것은 실제 아이디어가 없으므로, 그것은 행복하게 그럴 듯한 소리 답변을 생산할 수 있습니다. 두 번째, 그것은 절대 비공개 무언가를 알았습니다. 당신의 회사의 내부 문서, 사용자의 주문 역사, 당신의 데이터베이스의 내용: 그 중 어느 것도 그것이 학습한 공개 텍스트에 있었습니다, 그래서 그것은 알 수 없습니다, 당신이 얼마나 멋진지에 상관없이.

조용한 한계도 있습니다. 모델은 보통 그것이 "알고 있는" 어떤 것이 어디서 온 것인지를 말할 수 없습니다, 왜냐하면 그 지식은 그 안에 섞여 있는 것과는 대조적으로 별개의, 소싱된 사실로 파일되지 않았기 때문입니다. 그것은 당신에게 인용을 쓸 수 있으나, 그것은 실제 인용을 찾지 않고 인용이 어떻게 보이는지 예측하고 있습니다.

이것이 당신이 나중에 retrieval, 또는 RAG라고 불리는 기법의 이유입니다. 모델이 최근 이벤트 또는 당신의 자신의 비공개 데이터에 대해 답변하게 하려면, 당신은 그것을 재학습하지 않습니다. 당신은 관련된 텍스트 자신을 가져오고 요청 시간에 책상에 설정하므로, 모델은 추측하는 대신 자신의 앞에 있는 사실을 가집니다. 모델은 특정 사실의 신뢰할 수 있는 우물보다 당신이 주는 텍스트 위의 추론꾼입니다.

Juno모델이 알지 못하는 것 모델은 오직 학습 데이터에 있었던 것을 알며, 과거의 어떤 cutoff까지, 그래서 그것은 최근 이벤트 그리고 비공개, 그리고 그것은 신뢰할 수 없게 말할 수 있습니다 그것의 사실이 어디서 온 것인지. 현재 또는 비공개 정보가 필요할 때, 재학습하지 마세요: 관련된 텍스트를 가져오고, 그것을 요청에 전달하세요. 당신이 하는 당신의 일이 그것을 당신의 추론 위에서 읽는 것입니다, 당신이 주는 텍스트.

모델의 내장 지식, 그것의 parametric knowledge(그것의 가중치에 인코딩된 사실, 학습 중에 설정하는 튜닝 가능한 수)는 학습 cutoff에서 동결됩니다. 그 날짜 이후에 일어난 것은 그 안에 없고, 비공개였던 것은 절대 없었으므로, 가중치는 공개 텍스트에 의해 형성되었습니다. 그래서 기억은 당신에게 두 개의 예측 가능한 간격을 줍니다: 최근성, cutoff 이후의 무언가, 그리고 프라이버시, 비공개 학습 데이터에 절대 없었던 것.

이 두 간격은 정말로 두 측면에서 보인 하나의 간격이고, 그들은 같은 방법으로 문을 닫습니다: 필요한 텍스트를 요청에 놓으세요. 당신은 최근 기사 또는 관련 데이터베이스 행을 직접 가져오고 질문과 함께 공급하므로, 모델은 동결된 학습에서 회상하는 대신 사실을 읽습니다. 이것은 RAG 뒤의 핵심 아이디어이며, 검색 증대 생성입니다, 당신이 답변이 현재 또는 독점 정보를 반영해야 할 때마다 사용할 것입니다.

매개변수 지식은 또한 부착된 소스를 가지고 있지 않습니다. 사실은 가중치 전체에 섞여 있지 않고 다른 곳에 저장되어 있지 않은 문제로 확인하는 이산 항목 기록 이므로, 모델은 신뢰할 수 없게 당신에게 어디서 무언가가 왔는지를 말할 수 없습니다. 인용 그것은 생성하는 것은 기록에서 검색되지 않고 올바르게 보이도록 생성되는 것이며, 정확히 왜 당신이 공급하는 텍스트의 답변을 바탕으로 노력의 가치가 있는 것입니다.

구축을 위한 실제 규칙: 모델에 현재 또는 독점 사실을 기억에서 회상하도록 요청하지 마세요. 사실이 맞아야 하면, 그것을 가져오고 공급하고, 모델이 그것을 추론하도록 하세요.

Juno모델이 알지 못하는 것 매개변수 지식, 가중치에 인코딩된 사실, 동결 학습 cutoff에서 소스 부착 없이 동결, 그래서 모델은 최근 그리고 비공개 정보를 놓치고 무언가를 신뢰할 수 없게 인용할 수 없습니다. 두 간격 모두 같은 방법으로 문을 닫으세요: 관련된 텍스트를 가져오고 요청에 놓으세요, [RAG](/how-ai-works/rag) 뒤의 아이디어입니다. 규칙으로서, 모델에 현재 또는 독점 사실을 기억에서 회상하도록 요청하지 마세요; 공급합니다 그리고 그것이 추론하도록 하세요.

모델의 매개변수 메모리, 가중치에 유지된 지식(학습 중에 고정되는 튜닝 가능한 수), 버전이 없고 감사할 수 없습니다. 당신은 그것을 diff할 수 없으며, 주장이 사는 곳을 가리킬 수 없으며, 그것이 표류하지 않았는지 확인할 수 없습니다. 따라서 정확하고, 현재이고, 준수해야 하는 무언가에 대해서는, 모델의 말씀을 신뢰하지 마세요: 검색된 소스의 답변을 기반으로 하고 그 소스를 인용하세요. 내장 지식을 유창한 이전으로 취급하세요, 기록의 시스템이 아닙니다.

cutoff는 또한 단일 날짜가 제안하는 것보다 더 퍼져 있습니다. 학습 데이터는 그 날짜까지 오른쪽으로 균일하지 않습니다: 최근 자료는 오래된, 잘 다루어진 자료보다 더 얇고 더 적게 소화됩니다, 그래서 최근이지만 사전 cutoff 사실은 불균등하게 알려져 있습니다. 모델은 그 cutoff 1년 전 뭔가에 대해 자신감 있고 잘못될 수 있는 반면, 10년 전의 사실에 못을 박을 수 있으므로, "그것이 cutoff 전입니까?"는 보장보다 약합니다. 그것은 보입니다, 그리고 그것은 당신이 정확해야 하는 것을 검색하는 이유입니다.

간격에 대해 올바른 도구에 도달하세요, 왜냐하면 두 공통은 상호 교환할 수 없기 때문입니다. 검색은 요청 시간에 사실을 공급하고 당신의 소스가 업데이트할 때 현재를 유지합니다. Fine-tuning, 당신의 자신의 예제에서 계속 학습, 이동 형태 그리고 행동, 톤, 형식, 모델이 당신의 관례를 따르는 방법, 그리고 그것은 지식 주입을 하는 나쁘고 오래된 방법: 학습된 사실은 다시 동결되고, 업데이트하기 어렵고, 여전히 소싱되지 않았습니다. 사실에 대해 검색을 사용하세요, 그것이 어떻게 들려야 하는지에 대해 fine-tuning 하세요.

Juno모델이 알지 못하는 것 매개변수 메모리는 버전이 없고 감사할 수 없으므로, 정확하고, 현재이고, 준수해야 하는 것에 대해서는, 검색된 소스의 답변을 기반으로 하고, 모델의 말씀이 아니라 그 소스를 인용하세요. cutoff는 퍼져 있습니다: 최근이지만 사전 cutoff 사실은 불균등하게 알려져 있습니다, 그래서 정확해야 하는 것을 검색하세요. 그리고 간격에 대한 올바른 도구 일치: 검색은 사실을 공급하는 반면 fine-tuning은 형태 그리고 행동을 이동합니다 그리고 지식 주입을 하는 오래된 방법입니다.

모델이 왜 것을 만들어내는지

때때로 모델은 거짓으로 무언가를 완전한 확신으로 명시합니다: 아무도 말하지 않은 인용, 존재하지 않는 함수, 절대 작성되지 않은 연구에 대한 인용. 이것을 **hallucination**이라고 하며, 마지막 몇 섹션 이후 그것은 신비스럽기보다 거의 필연적으로 느껴야 합니다.

이유는 모델이 "참" 대 "거짓"에 대한 내부 감각이 없다는 것입니다. 그것은 "가능성 있는 텍스트" 대 "가능성 없는 텍스트"를 가지고 있습니다. 대부분의 시간, 그들은 정렬됩니다, 왜냐하면 그것이 배운 텍스트에서, 참 명시는 거짓보다 훨씬 더 일반적이므로, 가능한 지속은 보통 정확한 것입니다.

하지만 모델이 간격에 부딪칠 때, 그것이 절대 배운 무언가, 또는 당신의 비공개 데이터는 그것이 절대 볼 수 없었던 것, 그것은 멈추지 않고 간격을 플래그합니다. 그것은 신뢰할 수 없게 할 수 없습니다. 그것은 그것이 항상 하는 유일한 일을 합니다: 가장 가능한 음향 지속을 생성합니다.

자신감 있고 형성 잘된 잘못된 답변은 종종 정확히 가장 가능하게 점수합니다. 같은 기계가 그것을 유창하게 만드는 것이 그것이 틀렸을 때 유창하게 만듭니다.

앉아서 이 부분: hallucination은 완전히 프롬프트 떨어질 수 있는 결함이 아닙니다. 당신은 그것을 감소할 수 있고, 나중 장은 어떻게 보입니다. 모델이 "나는 알지 못한다"라고 말할 수 있다는 것을 말합니다 약간 도움. 당신이 공급하는 텍스트에서만 답변하도록 묻는 것은 훨씬 더 도움이 됩니다, 왜냐하면 지금 동결된 학습에서 채워질 간격이 없습니다. 하지만 경향은 모델이 근본적으로 무엇인지에서 옵니다, 사실 검사기 내부가 없는 확률 기계, 그래서 지속 가능한 수정이 구조: 모델이 작동해야 하는 사실을 제공하기 보다는 그것들이 그것의 학습에 있었기를 바라는 것, 그리고 중요한 것이 답변을 검증합니다.

이 장의 모든 다른 규칙을 통해 이 규칙을 가져가세요: 모델의 자신감은 당신에게 무언가를 알려줍니다 그것이 맞는지. 유창함 그리고 정확성은 같은 과정에서 생성되고 모든 시간을 떨어집니다. 단일 답변이 잘못될 수 있다는 것처럼 구축하세요, 왜냐하면 단일 답변이 할 수 있기 때문입니다.

Juno모델이 왜 것을 만들어내는지 hallucination은 모델이 가능한 텍스트를 채우는 것이 올바른 것이 아닙니다, 왜냐하면 그것은 "가능한" 그리고 "참"을 알지 못하기 때문입니다. 당신은 그것이 일어나는 빈도를 낮출 수 있지만, 완전히 프롬프트할 수 없으므로, 안전한 이동은 모델 사실을 건네고, 중요한 답변을 검사합니다. 그리고 확신하는 톤을 기억하세요 증거가 아니므로, 절대 그것에 단독으로 신뢰하세요.

모델이 인용, 함수, 또는 인용을 발명하고 완전한 확신으로 그것을 명시할 때, 그것은 hallucination이고, 그것은 모델이 작동하는 방식에서 바로 떨어집니다. 모델은 진실에 대한 신호를 가지지 않습니다. 그것은 "가능한 텍스트" 대 "가능성 없는 텍스트"로 지속을 점수 매기고, 대부분의 시간 가능한 그리고 참 겹치므로 배운 학습 데이터가 참 명시를 지배했으므로 문제에 가능한 지속은 정확한 것입니다.

hallucination은 그 겹침이 그것을 부수는 정확히 곳에서 스파이크입니다: 그것의 지식의 가장자리에서, 드문 또는 특수한 주제에서, 그리고 당신의 비공개 데이터에서 그것이 절대 배웠습니다. 거기 모델은 여전히 그것의 가장 가능한 지속을 생성합니다, 그리고 유창하고 형성 잘된 잘못된 답변은 종종 점수가 가장 높습니다.

그래서 당신은 이것을 단어만으로 수정할 수 없습니다, 하지만 당신은 얼마나 많이 영향이 실제로 도움이 되는 것으로 순위를 지을 수 있습니다. 가장 큰 레버 당신은 멀리 접지입니다: 실제 사실을 프롬프트에 놓고 모델에 그 공급된 텍스트에서만 답변하도록 말합니다, 이상적으로 그것을 인용합니다. 지금 동결된 학습에서 채워질 간격이 없습니다. 공급할 올바른 텍스트를 검색하는 것은 그것의 자신의 기술이고, RAG에서 다루어집니다.

아래 그것, 모델에 명시적인 탈출 해치를 주세요, "나는 알지 못합니다" 대신 추측하는 것으로 답변하는 허가, 추측을 거듭하기에 압력의 일부를 제거합니다. 그리고 온도(토큰 선택에 무작위성 다이얼)를 사실 일에 겸손하게 유지하세요, 높은 무작위성이 일어날 가능성이 낮고 떨어진 지속에 문을 넓히므로.

실제 결과: 모델을 당신이 공급하는 컨텍스트에 제약하고, 중요한 출력을 검증합니다. 프롬프트 구두점을 그러한 구조적 이동의 맨 위에 작은 조정으로 취급합니다, 절대 전체 방어로는 아닙니다. 확신한다고 들리는 모델은 그것이 정확한지에 대해 당신에게 무언가를 말했습니다, 왜냐하면 유창함 그리고 정확성은 같은 과정에서 옵니다 그리고 정기적으로 갈라집니다.

Juno모델이 왜 것을 만들어내는지 hallucination은 모델이 유창하고 형성 잘된 텍스트를 내보내고 진실 신호가 부착되지 않으며, 지식의 가장자리에서, 드문 주제에서, 데이터는 그것이 절대 보지 못했으므로 더 나쁩니다. 영향으로 수정 순위: 그것을 공급하는 텍스트에 접지(가장 큰 레버), 그것에 "나는 알지 못해"로 답변하는 방 주기, 공급된 컨텍스트 그리고 인용 이외에 답변하도록 말합니다, 사실 일을 위해 temperature 겸손을 유지합니다. 컨텍스트에 제약하고 중요한 출력을 검증합니다; 단어 속임수에만 기대지 마세요.

hallucination은 모델이 자신감 있고 형성 잘된 텍스트를 반환하고 그것이 거짓 일어나며, 그것은 건축, 버그가 아닙니다 당신은 패치합니다. 모델은 가능성이 있는 지속을 순위 매기고 진실 신호가 부착되지 않으므로, 배운 학습의 가장자리에서, 드문 주제에서, 신선한 이벤트, 무엇이든 비공개이고, 그것은 여전히 그것의 가장 가능한 추측을 내보냅니다. 당신은 이것을 제거하지 않을 것입니다. 일이 그것을 설계하는 것입니다, 그래서 잘못된 답변이 무언가 중요한 것에 도달하기 전에 잡혔거나 포함되었습니다.

이것은 세 구조적 이동을 의미합니다, 그 중 어느 것도 프롬프트 단어가 아닙니다. 모든 답변의 모양을 검증하세요: 모델이 스키마에 대한 데이터를 반환하도록 만들어서 잘못된 형태 또는 범위 밖 출력이 거짓 보다 다운스트림 흐르는 대신 거짓 모습, 이것이 무엇입니다 구조화된 출력 당신에게 구매합니다. 측정하세요 당신의 실제 hallucination 비율 evals로, 보유 입력 집합 알려진 좋은 답변 자동 점수 매기는, 보다 몇 프롬프트를 스팟 검사하고 그것을 부르는 것. 그리고 인간을 루프에 유지하세요 비용이 높은 곳 잘못된 것은, 자동화된 방어가 모든 것을 잡지 않기 때문입니다.

아래 이 모든 것의 함정은 보정입니다. 모델 확신은 나쁘게 보정됩니다: 명시 확실성은 정확성의 증거가 아니고 답변의 톤은 진실 가치에 대해 정보를 가지지 않습니다. 따라서 절대 게이트 모델이 확신하는 것을 들을 때 결정.

구축합니다 그리고 abstain 경로를 선호합니다, 승인된 "나는 무엇이 주어진 것에서 답할 수 없습니다", 그리고 그래서 abstaining 저렴하게 시스템이 아니라 추측 대신 그것을 찾습니다. 그 구조적 마음, 단일 답변이 잘못될 수 있다고 가정합니다 그리고 손상 포함, 전체 안전 그리고 제한 장은 위에 구축됩니다.

Juno모델이 왜 것을 만들어내는지 당신은 hallucination을 삭제할 수 없으므로, 포함을 위해 엔지니어: 스키마로 구조를 검증하고, evals로 비율을 측정하기보다 몇 출력을 안구화하고, 비용이 높은 곳에서 인간을 유지합니다. 모델 확신은 나쁘게 보정되므로, 확신한 톤은 증거가 아니고 당신은 절대 게이트합니다. 시스템이 abstain 저렴하고 sanctioned 방식을 제공합니다, 그리고 추측 대신 그것을 선호합니다.

함께 놓기

이 장의 모든 것은 다른 각도에서 보인 하나의 아이디어입니다. 모델은 동결된 숫자 더미이고 다음 토큰을 예측하며, 거의 모든 행동 당신이 다룰 이것에서 나옵니다:

• 그것은 한 번에 하나의 토큰을 예측하는 확률 순위에서, 그래서 그것은 즉흥적이며 회상 아닙니다, 그리고 무작위성(온도)의 터치는 답변이 다양하다는 것을 의미합니다.
• Tokens은 그것이 일하는 청크입니다: 당신의 청구의 단위, 당신의 크기 제한의 단위, 그리고 그것이 신뢰할 수 없게 셀 수 없는 이유입니다 편지.
• 컨텍스트 윈도우는 단일 요청의 책상입니다, 모든 것 공유, 그리고 모델 기억 아무것도 요청 사이에, 그래서 연속성은 당신의 일입니다.
• 그것의 지식은 학습 cutoff에서 동결되고 절대 당신의 비공개 데이터를 포함했고, 이것이 당신이 사실을 가져오고 프롬프트에 놓는 이유입니다.
• hallucination은 진실 감각이 없는 가능한 텍스트를 예측하는 시스템의 가격이고, 접지 그리고 검사로 감소되고, 절대 현명한 단어로입니다.

이것들을 함께 유지합니다 그리고 놀랍게도 많은 AI 엔지니어링이 서로 다른 의상에서 하나의 일로 켜집니다: 올바른 텍스트를 책상에 얻습니다, 올바른 모양에서, 정확히 옳은 시간에, 그리고 절대 출력이 맹목적으로 신뢰합니다. 다음 장, Open 그리고 폐쇄 모델은 어떤 종류 모델이 거기에 보이고 당신이 하나를 어떻게 얻습니까 보입니다, 그리고 그 다음 prompting은 당신이 시작하는 곳입니다 이 예측 모두를 당신이 실제로 원하는 것을 향해 조종.

Juno함께 놓기 거의 모든 것 모델에 대해 하나의 사실을 따릅니다: 그것은 동결된 숫자 집합이 다음 토큰을 예측합니다. 그로부터 다양한 답변, 토큰 기반 비용 그리고 제한, 요청 사이 기억 없음, 학습 cutoff, 그리고 hallucination. 이러한 모델로 구축하기의 많은 부분은 올바른 텍스트를 책상으로 얻는 것 그리고 절대 출력이 맹목적으로 신뢰입니다.

전체 장은 하나의 사실과 그것의 낙진입니다: 동결된 함수가 당신이 공급하는 텍스트 위의 다음 토큰을 예측합니다, 상태, 진실 신호, 그리고 계획 없음. 결과를 추적합니다 그리고 당신은 당신의 작동 모델을 가집니다:

• 예측 더하기 샘플링은 출력이 다양하다는 것을 의미합니다; 온도 설정하세요 얼마나.
• Tokens은 비용의 단위, 제한의 단위, 그리고 왜 문자 수준 작업 코드에 속합니다.
• 컨텍스트 윈도우는 유한 그리고 stateless이므로, 당신은 다시 보내고 모델이 필요한 모든 것을 큐레이트합니다.
• 지식은 cutoff에서 동결되고 소싱되지 않으므로 현재 그리고 비공개 사실은 회상이 아니라 검색에서 옵니다.
• hallucination은 구조적이고, 접지 그리고 검증으로 감소되고, 단어로 아닙니다.

모든 것 아래 패턴은 상수입니다: 올바른 텍스트를 컨텍스트에 올바른 모양에 올바른 시간에 얻고, 그 다음 검증합니다 뒤로 옵니다. 이것이 나머지 핸드북이 구축하는 것이고 열림 그리고 폐쇄 모델 경관로 시작하고 그 다음 prompting.

Juno함께 놓기 전체 장은 하나의 사실과 그것의 낙진입니다: 동결된, stateless 다음 토큰 예측기, 진실 신호 없음. 다양한 출력, 토큰 구동 비용, 유한 컨텍스트, 동결 지식, 그리고 보정되지 않은 자신감은 모두 corollaries이고, 당신의 harness는 하나를 포함하기 위해 존재합니다. 이점은 모델이 할 때 그것이 움직이지 않으므로, 버전 핀 그리고 실패 모드 주변 구축합니다.

하나의 문장 장을 실행합니다: 동결, stateless 다음 토큰 예측기, 진실 신호 없음. Stochastic 출력, 토큰 구동 비용, 유한 컨텍스트, 동결 지식, 그리고 보정되지 않은 자신감은 모두 corollaries이고, 당신의 harness는 하나를 포함하기 위해 존재합니다. 이점은 그것이 모델이 할 때 움직이지 않으므로, 버전 핀 그리고 실패 모드 주변 구축합니다.

나머지 핸드북이 harness입니다, 그리고 그것은 경관 열림 그리고 폐쇄 모델로 시작합니다, 그 다음 prompting.

Juno함께 놓기 하나의 문장이 장을 실행합니다: 동결, stateless 다음 토큰 예측기, 진실 신호 없음. Stochastic 출력, 토큰 구동 비용, 유한 컨텍스트, 동결 지식, 그리고 보정되지 않은 자신감은 모두 corollaries이고, 당신의 harness는 하나를 포함하기 위해 존재합니다. 이점은 모델이 할 때 그것이 움직이지 않으므로, 버전 핀 그리고 실패 모드 주변 구축합니다. 나머지 핸드북이 harness, 그리고 그것은 경관으로 시작합니다 [열림 그리고 폐쇄 모델](/how-ai-works/open-vs-closed-models), 그 다음 [prompting](/how-ai-works/prompting).