레이블이 machine learning인 게시물을 표시합니다. 모든 게시물 표시
레이블이 machine learning인 게시물을 표시합니다. 모든 게시물 표시

[컴][머신러닝] 프로그래머는 이제 곧 사라질까?

 프로그래밍을 계속 할 수 있을까

프로그래머는 이제 곧 사라질까?

eocnomist 의 기사다. 이전의 How AI models are getting smarter 에 이어지는 기사다. (참고: 생성형 AI 에 대한 대략적인 설명)

AI 가 인간을 대체할 수 있을까? 그리고 프로그래머는 이제 곧 사라질까? 이런 질문들에 대한 어느정도의 답이 된다.

기사

from : LLMs will transform medicine, media and more

의학, 미디어 등을 변화시킬 LLM / 하지만 (인간의) 도움 없이는 불가능합니다.

인공지능(AI)는 컴퓨터가 어떤 일을 똑똑하게(인간기준으로) 하는 기술

그런 의미에서 이미 AI 는 많이 쓰이고 있다. 네비게이션의 길찾기, 과속차량 번호판의 인식, 온도 조절기등은 모두 AI 에 속합니다.

AI 가 일관되고, 안정적으로 작동하면, 그것은 그냥 엔지니어링이라 부릅니다.

현재 전 세계의 주목을 받으며 엄청난 양의 컴퓨팅 파워와 전력을 빨아들이고 있는 인공지능딥러닝이라는 기술을 기반으로 합니다.
딥러닝에서는 선형대수(특히 행렬 곱셈)통계를 사용하여,
학습과정에서 대규모 데이터 세트에서 패턴을 추출하고 그래서 학습하는 것이 됩니다.

Google의 Gemini나 OpenAI의 GPT와 같은 대규모 언어 모델(LLM)은 수많은 텍스트, 이미지, 동영상으로 학습되어 왔다. 그리고 많은 능력을 개발한 상태입니다.
이미지, 음악, 로봇공학, 유전체학, 의학, 기후, 날씨, 소프트웨어 코딩등, 보다 전문화된, 도메인에 특화된 버전의 모델이 존재합니다.

연구자들은 여전히 AI가 무엇을 할 수 있고 무엇을 할 수 없는지 파악하고 있습니다. 지금까지는 더 많은 데이터로 학습된 더 큰 모델이 더 뛰어난 능력을 발휘하는 것으로 입증되었습니다. 이는 계속해서 더 많은 데이터를 추가하면 더 나은 AI를 만들 수 있다는 믿음을 심어주었습니다. 모델 크기와 학습 데이터의 양이 어떻게 상호 작용하여 LLM을 향상시키는지 보여주는 ’확장 법칙’에 대한 연구가 수행되었습니다.

더 나은” LLM이란 무엇일까요? 질문에 정답을 맞히거나 창의적인 아이디어를 제시하는 모델일까요?

지금까지 AI의 힘은 개별 작업에서 가장 두드러집니다.
하지만 open-ended task에서의 성능은 평가하기가 더 어렵습니다.

오늘날의 대규모 AI 모델은 학습 데이터에 표현된 패턴을 기반으로 시(poetry)에서 실사 이미지에 이르기까지 다양한 것을 생성하는 데 매우 능숙합니다.
그러나 이러한 모델은 생성한 것 중 어떤 것이 가장 의미가 있거나 주어진 상황에 가장 적합한지를 판단하는 데는 능숙하지 못합니다.

논리와 추론 능력도 떨어집니다. AI에게 일관되게 추론할 수 있는 능력을 제공하기 위해 더 많은 데이터를 주면 될 것인지, 아니면 완전히 다른 종류의 모델이 필요한 것인지에 대해서는 아직 명확치 않다.
오랜 시간 동안 AI의 한계가 존재할 수 있다. 그로 인해 이를 활용하기 위해서는 인간의 추론이 필요할 것이다

이러한 한계가 무엇인지 알아내는 것은 의료와 같은 분야에서 중요합니다. AI를 적절히 활용하면 암을 조기에 발견하고, 서비스에 대한 접근성을 확대하고, 진단을 개선하고, 개인 맞춤형 치료를 제공할 수 있습니다. 4월에 발표된 메타 분석에 따르면 AI 알고리즘은 이러한 작업에서 인간 임상의보다 더 나은 성과를 낼 수 있습니다. 하지만 인공지능의 훈련이 그들의 길을 잃게 할 수 있다. 즉, 사람이 개입하는 것을 제한하는 방향으로 훈련될 수도 있다.

예를 들어, AI 모델은 ‘데이터 분포 변화’(“data distribution shifts”)로 인해 더욱 부각된 인간의 편견에 취약한데, 백인의 피부 이미지로 주로 학습한 후 흑인의 피부 이미지를 제공하면 진단 모델이 실수를 할 수 있습니다.

'AI'와 '자격을 갖춘 사람'을 결합하는 것이 가장 효과적인 것으로 입증되었습니다. 이 논문에 따르면 AI를 사용한 임상의는 정확하게 암이라고 진단한 사람의 비율을 81.1%에서 86.1%로 늘릴 수 있었으며, 암이 없다고 정확하게 진단한 사람의 비율도 늘릴 수 있었습니다.

AI 모델은 인간과 다른 실수를 저지르는 경향이 있기 때문에 AI와 인간의 파트너십이 AI 단독으로 일을 하거나, 인간 단독으로 일을 하는 것보다 더 뛰어난 성과를 보이는 것으로 나타났습니다.

로봇방식

과학 분야에서 새로운 가설을 탐구하는 데 지금보다 사람이 덜 필요할 수도 있습니다. 2009년 케임브리지 대학교의 로스 킹 박사는 자신의 궁극적인 목표는 자율 실험실, 즉 ’로봇 과학자’로 기능하는 시스템을 설계하는 것이라고 말했습니다. 킹 박사가 개발한 AI 과학자 아담은 가설을 세우고, 로봇 팔을 사용해 실험을 수행하고, 센서를 통해 결과를 수집하고 분석하도록 설계되었습니다. 대학원생이나 박사후 연구원과 달리 아담은 식사나 수면을 위해 휴식을 취할 필요가 없습니다. 그러나 이러한 유형의 AI 시스템은 현재로서는 신약 개발 및 재료 과학과 같은 비교적 좁은 영역으로 제한되어 있습니다. 인간이 주도하는 연구보다 훨씬 더 많은 이득을 가져다줄 수 있을지는 아직 불분명합니다.

AI 기술은 수십 년 동안 과학 분야에서 데이터를 분류, 선별, 분석하고 예측하는 데 사용되어 왔습니다. 예를 들어, Project CETI의 연구원들은 고래 발성 데이터 세트를 수집한 다음 이 데이터로 AI 모델을 학습시켜 어떤 소리가 의미를 가질 수 있는지 알아냈습니다. 또는 구글 딥마인드에서 개발한 심층 신경망인 ’알파폴드’를 생각해 보세요. 방대한 단백질 데이터베이스로 훈련된 이 시스템은 사람이 며칠 동안 세심하게 실험하고 측정해야 했던 단백질의 3차원 모양을 빠르고 정확하게 예측할 수 있습니다. 딥마인드에서 개발한 또 다른 AI 시스템인 GNoME는 특정 화학적 특성을 가진 새로운 물질을 발견하는 데 도움을 주기 위한 것입니다(다이어그램 참조).

AI는 입자 충돌기의 결과를 선별하여 새로운 아원자 입자(subatomic particles)를 식별하거나, 과학 문헌을 따라잡는 등 연구자가 감당하기 힘든 대량의 데이터 흐름을 이해하는 데도 도움이 될 수 있습니다. 아무리 세심한 독서가라도 자신의 연구와 관련이 있을 수 있는 모든 과학 논문을 소화하는 것은 불가능에 가깝습니다. 이른바 문헌 기반 발 시스템(literature-based discovery system)은 이러한 산더미 같은 텍스트를 분석하여 연구의 빈틈을 찾아내고, 오래된 아이디어를 새로운 방식으로 결합하거나 새로운 가설을 제안할 수 있습니다.

하지만 이러한 유형의 AI 작업이 유익한지 여부를 판단하기는 어렵습니다. AI는 예상치 못한 연역적인 도약을 하는 데 인간보다 더 뛰어나지 않을 수도 있고, 대신 단순히 전통적이고 잘 알려진 연구 경로를 선호하여 흥미로운 결과를 내지 못할 수도 있다

교육계에서는 AI, 특히 ChatGPT와 같은 봇이 오히려 독창적인 사고를 방해할 수 있다는 우려가 있습니다. 2023년 교육 기업 Chegg의 조사에 따르면 전 세계 학생의 40%가 학교 과제를 할 때 AI를 사용했으며, 주로 작문을 위해 사용했습니다. 이로 인해 일부 교사, 교수, 학군에서는 AI 챗봇 사용을 금지하고 있습니다.

많은 사람들이 챗봇을 사용하면 문제를 해결하거나 논쟁을 벌이는 과정에서 문제 해결 능력과 비판적 사고력을 키우는 데 방해가 될 수 있다고 우려하고 있습니다.

다른 교사들은 완전히 다른 접근 방식을 취하여 AI를 도구로 받아들이고 과제에 통합하기도 합니다. 예를 들어, 학생들에게 ChatGPT를 사용하여 주제에 대한 에세이를 작성한 다음 틀린 부분에 대해 비평하도록 요청할 수 있습니다.

잠깐만요, 챗봇이 이 글을 쓴 건가요?

오늘날의 생성형 AI는 버튼 클릭 한 번으로 텍스트를 생성할 뿐만 아니라 이미지, 오디오, 동영상을 단 몇 초 만에 생성할 수 있습니다. 이는 팟캐스트에서 비디오 게임, 광고에 이르기까지 미디어 비즈니스의 판도를 바꿀 수 있는 잠재력을 가지고 있습니다.

AI 기반 도구는 편집을 간소화하고 시간을 절약하며 진입 장벽을 낮출 수 있습니다.

하지만 AI로 제작된 콘텐츠는 일러스트레이터나 성우와 같은 일부 아티스트들을 위험에 빠뜨릴 수 있습니다. 시간이 지나면 인간 배우의 AI 기반 복제품(simulacrum) 또는 완전히 인공적인 배우를 사용하여 영화 전체를 제작하는 것이 가능할 수도 있습니다.

하지만 AI 모델은 스스로 문제를 만들거나 해결할 수 없습니다(아직까지는). 인공지능은 정교한 소프트웨어일 뿐, 지각 능력이 있거나 자율적인 존재가 아닙니다. AI는 자신을 호출하고, 자신에게 묻고, 그 결과를 적용 또는 폐기하는 것을 하는데에 있어 인간 사용자에게 의존합니다. 좋든 나쁘든 AI의 혁신적인 능력은 여전히 인간과 인간의 판단에 달려 있습니다.

[컴][머신러닝] 생성형 AI 에 대한 대략적인 설명

generative AI / 설명 / 간략설명 / 이해

생성형 AI 에 대한 대략적인 설명

경제지 economist 에서 생성형AI 에 대해 간략하게 이야기해주고 있다. 생성형 AI 가 어떻게 동작하는지 이해를 도와줘서 옮겨놓는다. 개인적으로 필요한 부분만 옮겨놓은 것이라서, 완전한 글은 본문을 참고하자.

기사

from : How AI models are getting smarter, 2024-08-06

뉴런들을 네트워크에 연결하고, 뉴런들을 네트워크에 계층화하는 여러방법이 있다.
이런 아키텍쳐의 발전이 좀 더 학습이 쉽고, 좀 더 나은 결과를 가져다 주는 신경망을 만드는 데 도움이 됐다.

현재 관심은 text를 위한 LLM(Large language model)과 image를 위한 diffusion model 들에 집중되어 있다.
이 모델들은 이전 모델들보다 더 많은 뉴런층을 가지고 있으며, 방대한 데이터를 빠르게 처리할 수 있는 방식으로 구성됐다.

transformer architecture 를 기반으로 LLM 들이 만들어졌다. 트랜스포머는 2017년에 Google Brain의 아시시 바스와니와 그의 팀이 소개했는데, 이 트랜스포머의 핵심 원리는 ‘attention’(주의) 이다.
attention layer는 모델이 입력값들의 여러 측면들 — 예를 들면, 텍스트에서 서로 일정한 거리에 있는 단어들 — 이 서로 어떻게 연결되어 있는지를 학습할 수 있게 해준다. 그리고 이를 output을 만드는 과정에 반영할 수 있도록 해준다.

한 row 에 많은 attention layer들이 있으면, 모델은 단어, 구(phrase) 심지어 문단 사이에 있는 다양한 수준의 세밀한부분에서(at different levels of granularity) 연관성을 학습할 수 있게 된다.

transformer 기반의 모델들은 text뿐만 아니라 image 도 생성할 수 있다.
OpenAI 가 2021년에 출시한 DALL-E 의 첫번째 버전은 이미지의 픽셀 그룹간의 연관성을 학습하는 트랜스포머였다.
신경망은 그것이 보는 것을 숫자로 변환하고, 이에 대해 수학(특히, 행렬연산)을 행한다.

트랜스포머에는 한계가 있다. 일관되게 세계(world)를 표현하는 model 을 학습하는 것이 어렵다.
이 트랜스포머 기반 모델은 인간의 질문에 답할 때, 한 답변에서 다음 답변으로 넘어가면서 스스로 모순된 답변을 할 수 있다. 이것은 첫번째 답변이 두 번째 답변을 모순되게 만든다는 것을 이해하지 못하기 때문이다.
이 모델은 실제로 그 답변을 이해해서 알고있는 것이 아니라, 단순히 답변처럼 보이는 특정 문자열들의 연관성만 알고 있기 때문이다.

트랜스포머 기반 모델은 잘못된 답을 만들고, 그럴 듯한 가짜 인용을 만들어내는 ‘환각’(hallucinations)이 발생하기 쉽다.
마찬가지로, 초기 트랜스포머 기반 모델에서 생성된 이미지는 종종 물리 법칙을 위반하고 받아드리기 어려운 경우가 많았다(일부 사용자에게는 기능일 수 있지만 사실적인 이미지를 생성하려는 디자이너에게는 버그였다). 다른 종류의 모델이 필요했다.

diffusion model(확산 모델)들은 훨씬 더 사실적인 이미지를 생성할 수 있다.
diffusion model의 주요아이디어는 확산의 물리적과정에서 영감을 받았다. 뜨거운 물 한 컵에 티백을 넣으면 찻잎이 가파르게 가라앉기 시작하고, 차의 색이 맑은 물로 스며들어 흐려진다. 몇 분 동안 그대로 두면 컵에 담긴 액체가 균일한 색을 띠게 된다.

이 확산 과정은 물리 법칙에 의해 결정된다. 물리 법칙을 사용하여 차가 어떻게 확산될지 예측할 수 있는 것처럼, 이 과정을 역설계하여 티백이 처음 어디에 어떻게 떨어졌을지 재구성할 수도 있다. 현실에서는 이미 벌어진 일을 뒤로 돌릴 수 없지만, 엔트로피를 역전시키는 과정을 시뮬레이션하는 법을 학습하면 사실적인 이미지 생성이 가능해진다.

훈련(training)은 다음과 같이 작동한다.
이미지를 가져와서 완전히 무작위로 보일 때까지 점점 더 많은 흐림(blur)과 노이즈를 적용합니다. 그 다음, 이부분이 어려운 부분인데, 이 과정을 역으로 진행하여 차에서 티백을 찾아내는 것처럼 원본 이미지를 다시 만드는 것이다.

이 작업은 “self-supervised learning”(자기 지도 학습)을 통해 이뤄진다. text에서 LLM이 훈련되는 방식과 유사하다.
그것은 문장에서 단어를 가리고, 시도와 오류(trial and error)를 통해 누락된 단어를 예측하는 방법이다.

이미지의 경우, 네트워크는 원본 이미지를 재생산하기 위해 점점 더 많은 양의 노이즈를 제거하는 방법을 학습한다. 수십억 개의 이미지를 처리하면서 왜곡을 제거하는 데 필요한 패턴을 학습하게 되면, 네트워크는 아무것도 없는 무작위 노이즈에서 완전히 새로운 이미지를 생성할 수 있는 능력을 얻게 된다.

대부분의 최첨단 이미지 생성 시스템은 디퓨전 모델을 사용하지만, 노이즈 제거 또는 왜곡을 역전(reversing distortions)시키는 방식은 서로 다르다.

2022년에 출시된 Stable Diffusion(Stability AI의)과 Imagen은 모두 컨볼루션 신경망(CNN)이라는 아키텍처의 변형을 사용했습니다. CNN은 그리드 형태의 데이터를 분석하는 데 뛰어납니다. 픽셀의 행과 열 같은.
실제로 CNN은 입력된 데이터에서 작은 슬라이딩 창을 위아래로 움직이며 패턴이나 모서리와 같은 특정 객체(artefacts)를 찾는다.

CNN은 픽셀에서 잘 작동하지만, 최신 이미지 생성기 중 일부는 확산 트랜스포머(difffusion transformers)를 사용한다. 스테이빌리티 AI의 최신 모델인 Stable Diffusion 3가 여기에 포함된다. 확산에 대한 훈련을 받은 트랜스포머는 이미지나 비디오 프레임의 다양한 부분이 서로 어떻게 연관되어 있는지, 그리고 얼마나 강하게 또는 약하게 연결되어있는지를 훨씬 더 잘 알아낼 수 있어서 보다 사실적인 결과물을 만들어낸다.(여전히 실수가 있긴 하지만).

추천시스템(Recommendation systems) 은 다른 문제다.(kettle of fish)
이러한 시스템의 추천 알고리즘을 구축하고 사용하는 회사들은 추천 알고리즘에 대해 극도로 비밀을 유지하기 때문에 내부 구조를 엿볼 기회는 드물다.

그러나 2019년 Meta(당시 Facebook)는 자사의 딥러닝 추천 모델(DLRM)에 대한 세부 정보를 공개했다. 이 모델은 세 가지 주요 부분으로 구성되어 있다.

  1. 입력(예를 들어 사용자의 나이, 플랫폼에서의 ‘좋아요’, 또는 소비한 콘텐츠 등)을 ’임베딩(embeddings)’으로 변환합니다.
  2. 이 임베딩 공간에서 유사한 것들(예를 들어 테니스와 탁구)이 서로 가까운 위치에 있도록 학습합니다.
  3. 그런 다음 DLRM은 신경망을 사용하여 행렬 인수분해(matrix factorisation)라는 작업을 수행한다. 스프레드시트를 상상해보자, 칼럼들은 동영상들이고 row들은 다양한 사용자들이다.
    각 셀(cell)들은 각 사용자가 각 동영상을 얼마나 좋아하는지를 나타낸다.
    그러나 대부분의 셀은 비어있다.
    추천의 목표는 모든 빈 셀에 대해 예측(prediction)을 하는 것이다.
  4. 딥러닝 추천 모델(DLRM)이 이를 수행하는 한 가지 방법은 그리드를 2개의 행렬(grid)로 나누는 것이다.
    하나는 사용자에 대한 데이터를 포함하는 행렬(grid)과 다른 하나는 동영상에 대한 데이터를 포함하는 행렬(grid)로 나누는 것이다.(수학 용어로 행렬을 인수분해).
  5. 이러한 행렬(grid)을 재결합(즉, 행렬 곱셈)을 하고
  6. 그 결과를 다른 신경망에 입력으로 제공하여 추가적인 수치 계산을 수행하면 비어 있던 셀을 채울 수 있다.
    즉, 각 사용자가 각 동영상을 얼마나 좋아할지 예측할 수 있다.

비슷한 방식은 광고, 스트리밍 서비스의 노래, 이커머스 플랫폼의 제품 등에도 적용할 수 있다.
기술 기업들은 이와 같이 상업적으로 유용한 작업을 잘 수행하는 모델에 가장 큰 관심을 보입니다. 하지만 이러한 모델을 대규모로 실행하려면 막대한 비용과 방대한 양의 데이터, 엄청난 처리 능력(processing power)이 필요합니다.

학술적 맥락에서는, 데이터셋이 작고 예산이 제한적이기 때문에 다른 종류의 모델이 더 실용적입니다.
이러한 모델에는 순환 신경망(데이터의 시퀀스를 분석하기 위해 사용됨), 변이형 오토인코더(variational autoencoders, VAE)(데이터에서 패턴을 발견하기 위해 사용됨), 생성형 적대 신경망(generative adversarial networks, GAN)(하나의 모델이 다른 모델을 반복적으로 속이면서 작업을 배우는 방식), 그래프 신경망(복잡한 상호작용의 결과를 예측하기 위해 사용됨)이 포함된다.

심층 신경망, 트랜스포머, 확산 모델이 모두 연구적 호기심에서 광범위한 배포로 발전한 것처럼, 이러한 다른 모델의 특징과 원리는 미래의 AI 모델에 활용되고 통합될 것이다. 트랜스포머는 매우 효율적이지만, 이를 확장한다고 해서 환각과 추론 시 논리적 오류를 범하는 경향을 해결할 수 있는지는 확실하지 않다. 이러한 약점을 극복하고 다음 단계로 나아갈 수 있는 “상태 공간 모델(state-space models)”부터 “신경-상징적(neuro-symbolic)” AI에 이르는 ‘포스트 트랜스포머’ 아키텍처에 대한 탐색이 이미 진행 중이다. 이상적으로는 이러한 아키텍처가 더 뛰어난 추론 능력을 겸비한 주의(attention)을 갖는 것이 이상적이다. 현재로서는 그런 모델을 어떻게 구축할지 아는 사람은 없습니다. 언젠가는 AI 모델이 이 작업을 해낼 수도 있을 것이다.

[컴][머신러닝] windows 에서 ollama 사용

 

llama / llm / 윈도우즈 /

windows 에서 ollama 사용

다음 링크에서 Ollama windows version 을 download 하자.

설치를 하면 %AppData%\Local\Programs\Ollama에 자동으로 설치된다. 대략 1.6GB 정도 여유공간이 필요하다.

  • %AppData%\Local\Programs\Ollama

아래와 같은 방식으로 실행하면 된다. model 이 없으면 model 을 download 하고, 실행한다. ollama run llama2 를 하면 llama2 model 을 다운로드하게 된다. 대략 3.8GB 이다. 이 model 은 %UserProfile%\.ollama 에 저장된다.

ollama run llama2
>>> Send a message (/? for help)
ollama list

Ollama WebUI

Ollama WebUI 가 있다. 아래는 linux 에서 설치방법이다.

sudo docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main
sudo docker run -d --network=host -v ollama-webui:/app/backend/data -e OLLAMA_API_BASE_URL=http://172.17.192.1:11434/api --name ollama-webui --restart always ghcr.io/ollama-webui/ollama-webui:main

[컴] AI 에서 어떻게 model 을 디자인 하는 것일까?

 

AI 에서 어떻게 model 을 디자인 하는 것일까?

아래 영상을 보고 간단하게 keras 를 이용해서 ai model 을 만들어볼 수 있다.

  • Make Your First AI in 15 Minutes with Python - YouTube
  • 에러
    • ValueError: Input 0 of layer "sequential_1" is incompatible with the layer: expected shape=(None, 455, 30), found shape=(None, 30) 와 같은 에러가 발생하는데 code에서 model.add(tf.keras.layers.Dense(256, input_shape=x_train.shape[1:], activation='sigmoid')) 로 변경하면 된다. x_train.shape 대신 x_train.shape[1:]를 사용하는 것이다.

여기서 궁금중은 그러면 model 을 만들때 사용한 layer를 어떤 기준으로 추가했느냐이다. 그리고 그 layer에 사용한 activation function 은 어떤 기준으로 선택했는가 이다.

model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Dense(256, input_shape=x_train.shape, activation='sigmoid'))
model.add(tf.keras.layers.Dense(256, activation='sigmoid'))
model.add(tf.keras.layers.Dense(1, activation='sigmoid'))

그럼 어떻게 model 을 만들까?

이것에 대한 대답을 다음 글에서 확인할 수 있을 듯 하다.

이글은 deep learning 의 성능을 향상시키는 방법을 이야기하는데, 여러가지 방법이 있다.

  • 데이터양을 증가시키는 방법
  • 데이터를 normalize 하는 법
  • 데이터를 시각화해서 모양을 봐보라, 그러면 이것이 가우스분포같은지, log분포같은지등을 보고, 필요한 변환을 해볼 수 있다.
  • feature selection
  • 문제를 구성하는 방법을 변경해봐라
  • 여러 알고리즘을 통한 향상
    • 선택한 알고리즘이 best가 아닐 수 있다. linear methods, tree methods, instance methods, 다른 neural network methods 들로 평가해봐라.
    • 논문등 다른 사람들이 했던 비슷한 문제들을 찾아서 아이디어를 얻어라(리서치를 해라)
    • 샘플링한 dataset을 다시 잘 sampling 한다. 예를 들어 train/test 로 나눴다면, train 에 해당하는 dataset이 문제의 대표성을 띠는지 등. 또는 작은 dataset을 사용하고, 그에 맞는 model을 선택해서 테스트해보고 큰 dataset으로 확장해 볼 수도 있다.
  • 알고리즘 튜닝을 통한 향상
    • 진단, overfitting인지 underfitting인지
    • 가중치 초기화
    • 학습률을 조정
    • activation function
    • network topology , 여러가지 구성을 테스트해본다. 1개의 많은 newrons를 갖는 hidden layer를 시도하던지, layer당 적은수의 neuron들을 갖는 deep network 를 시도하던지, 이 2개를 전부해보던지등.
    • batches and Epochs, batch size를 변경하는 것은 gradient를 정의하고, weight들을 얼마나 자주 update하는지를 정한다. epoch는 배치마다 ‘network 에 노출되는 전체 dataset’ 이다.
    • 정규화, overfitting을 억제하는 좋은 방법이다. dropout이라는 정규화기술도 있다.
    • 최정화와 손실, 이전에 최적화는 ‘확률적 경사하강법(stochastic gradient descnet)’ 였지만, 이젠 많은 optimizer들이 있다.
    • 빠른 정지(Early Stopping), 성과가 저하되기 시작하면 학습을 중단한다. 그리고 다른 sample을 만들던지 하는등으로 시간을 절약할 수 있다.

[컴] rust llama-chat.wasm 을 wasmedge 에서 실행

rust llama-chat.wasm 을 wasmedge 에서 실행

wasmedge, rust llama-chat 을 실행하는 이야기다. ref. 2 를 확인하면 된다.

여기서는 ref.2 의 내용을 직접 해봤다.

실행한 사양

  • windows wsl2 의 ubuntu 20.04
  • ram 16gb
  • cpu i5-9400F @ 2.90GH

짤막한 소감

wsl2 여서 그런지 gpu 인식을 제대로 안됐다. 그래서 CPU 만으로 추론(inference)이 된다.

개인적으로 wsl2의 memory 는 대략 8GB까지 올라갔다.

1번째 질문은 1분내에 응답을 했다. 다만 2번째 질문부터는 5분정도 기다려도 답변이 나오지 않았다.

실행

curl -sSf https://raw.githubusercontent.com/WasmEdge/WasmEdge/master/utils/install.sh | bash -s -- --plugin wasi_nn-ggml
# After installing the wasmedge, you have to activate the environment.
# Assuming you use bash (the default shell on Ubuntu), you will need to run the following command
source $HOME/.bashrc

pre-built Wasm app

curl -LO https://github.com/second-state/llama-utils/raw/main/chat/llama-chat.wasm
sudo apt update
sudo apt install -y libopenblas-dev
wasmedge --dir .:. --nn-preload default:GGML:AUTO:llama-2-7b-chat-q5_k_m.gguf llama-chat.wasm

Reference

  1. WasmEdge-WASINN-examples/wasmedge-ggml-llama-interactive/README.md at master · second-state/WasmEdge-WASINN-examples · GitHub
  2. Fast and Portable Llama2 Inference on the Heterogeneous Edge

[컴][머신러닝] E5-large-v2 로 블로그글에 대한 답변 얻기

E5-large-v2 로 블로그글에 대한 답변 얻기

Disclaimer

이글은 필자의 이해를 바탕으로 재작성했다. 틀린 부분이 있을 수 있다.

overview

보통 우리의 검색은 indexing 된 정보를 가져다 준다. 그래서 A라는 키워드를 넣으면, 그에 맞는 값들을 던져준다. 이것을 chatgpt 에게 대신할 수 있다. 다만 chatgpt 는 blog 의 모든 글을 읽고 그것을 재구성해서 우리에게 던져줄 수 있다.

이 e5-large-v2 모델은 질문을 던지면, 가지고 있는 답변 문장중에 가장 근접한 것을 던져준다.

Contrastive Learning

ML(machine learning)방법중 Contrastive Learning(대조적 학습)이 있다. self-supervised learning의 일종이다.

이 학습은 positive pair(양성쌍), negative pair(음성쌍)의 data 를 만들고, 이러한 쌍들을 이용해서 모델을 학습시키는 방법이다.

이 data pair 는 사람이 labeling 해서 줄 수도 있고, AI 가 특정 알고리즘을 이용해서 스스로 할 수 도 있다. 이렇게 얻어진 data 로 model 을 학습하게 되면, 이를 통해 이 model 은 데이터 간의 비슷한점(similarity)과 차이점(difference)을 이해하고 패턴을 학습하게 된다.

E5-large-v2 model

E5-large-v2 model 은 질문(query)과 그에 맞는 답변(passage)를 가지고 학습한 model이다.(query, passage 의 pair) 그래서 질문을 던지는 경우, 그 질문을 embdding 하고, 그 값을 현재 저장된 embedding 에서 similarity 가 높은 것들을 가져온다.

query 에 대한 embedding 을 뽑고, 이것을 저장된 embedding 인 blog-paragraphs 에서 찾아 본다. 그러면 유사한 query 를 찾아낼 수 있다. 그러면 그 query 에 딸려있는 passage 를 결과로 주면 된다.

llm similar blog-paragraphs -c 'query: what is LLM?'

HuggingFace Inference API

https://huggingface.co/intfloat/e5-large-v2 에서 ‘Inference API’ 로 테스트를 해보면 이 모델이 질문을 던질때 어떤 답변을 줄지 확인해 볼 수 있다.

  • Source Sentence 에는 내가 model 에 input 으로 넣고 싶은 값
  • Sentences to compare to 에는 input texts, 즉 내가 model 에게 줄 context

값을 넣으면 된다.

llm

pip install llm
llm install llm-sentence-transformers

자신이 쓰려는 model 을 local 에 설치한다.

llm sentence-transformers register intfloat/e5-large-v2 -a lv2

sentence transformer

embedding들을 위한 python framework 이다. 기술적인 문장(state-of-the-art sentence), 문서, 이미지에 대해 embedding 을 해준다. 원하는 model 을 선택하고, 그 model 을 기준으로 한 embedding 을 얻을 수 있다.

여기서 사용하는 pretrained model 은 HuggingFace 같은 곳에서 serve 하는 model들이다.

SentenceTransformer는 아래 예시를 보면 이해가 될 것이다.

#
# source from : [Usage](https://www.sbert.net/#usage)
#
from sentence_transformers import SentenceTransformer
model = SentenceTransformer('all-MiniLM-L6-v2')

#Our sentences we like to encode
sentences = ['This framework generates embeddings for each input sentence',
    'Sentences are passed as a list of string.',
    'The quick brown fox jumps over the lazy dog.']

#Sentences are encoded by calling model.encode()
embeddings = model.encode(sentences)

#Print the embeddings
for sentence, embedding in zip(sentences, embeddings):
    print("Sentence:", sentence)
    print("Embedding:", embedding)
    print("")

intfloat/e5-large-v2 · Hugging Face

from sentence_transformers import SentenceTransformer
model = SentenceTransformer('intfloat/e5-large-v2')
input_texts = [
    'query: how much protein should a female eat',
    'query: summit define',
    "passage: As a general guideline, the CDC's average requirement of protein for women ages 19 to 70 is 46 grams per day. But, as you can see from this chart, you'll need to increase that if you're expecting or training for a marathon. Check out the chart below to see how much protein you should be eating each day.",
    "passage: Definition of summit for English Language Learners. : 1  the highest point of a mountain : the top of a mountain. : 2  the highest level. : 3  a meeting or series of meetings between the leaders of two or more governments."
]
embeddings = model.encode(input_texts, normalize_embeddings=True)

local 의 model 사용

local 의 model 을 이용하려면 local 에 model 을 다운로드 하고, local path 를 적어주면 된다. (참고: How to load huggingface model/resource from local disk? - Stack Overflow)

huggingface 를 git clone 하면, model file들이 download 된다. 이것을 SentenceTransformer에서 사용하면 된다.

Reference

  1. Embedding paragraphs from my blog with E5-large-v2 | Simon Willison’s TILs

[컴][머신러닝] ai 로 쓴 글을 구별하긴 어렵다.

 

생성형 ai / 구별 / 어렵다

ai 로 쓴 글을 구별하긴 어렵다.

OpenAI가 사람의 글쓰기와 AI 생성 텍스트를 구별하는 것을 목표로 한 도구의 정확도가 낮아서 종료하기로 결정 업데이트된 블로그 글 내용에서, OpenAI는 7월 20일을 기준으로 이 AI 판별기(classifier)를 중단하기로 했다고 밝혔습니다. “우리는 피드백을 반영해 현재 더 효과적인 텍스트 출처 기술에 대해 연구 중입니다.”라고 회사 측은 말했습니다.

  • [인공지능 탐지기가 미국 헌법이 인공지능에 의해 작성되었다고 생각하는 이유 - All Things IT @AI](https://ai.atsit.in/posts/9244386115/), 2023-07-14 : ai 감지 개념에 대한 이야기

[컴][머신러닝] gpt4all 사용

local pc / machine learning / 생성형 ai / 챗gpt 로컬에서 사용 / 로컬 gpt / 로컬 chatgpt / chatgpt

gpt4all 사용

환경

  • windows10
  • ram 16GB
  • intel(R) core i5-9400F CPU@2.90GHz

GPT4All

  • Nomic AI 에서 만들었다.
  • 이 프로그램은 LLM 을 이용해서 chat 을 할 수 있도록 해주는 client 이다. 그래서 LLM 을 가지고 있진 않다. 설치후 다운로드 받아서 사용하도록 되어 있다.
  • https://github.com/nomic-ai/gpt4all : 이 applicaiton 을 직접 build 도 할 수 있다.
  • local cpu 에서 돌아가도록 되어있다. 그래서 CPU는 AVX 또는 AVX2 instruction 을 지원해야 한다. 대략 2011년 3Q 이후에 나온 cpu 면 다 지원되는듯(참고: https://en.wikipedia.org/wiki/Advanced_Vector_Extensions)

사용해보기

설치 파일(gpt4all-installer-win64.exe)을 받고 실행하면 된다. (여기로 가면 된다.)

설치하고 설치된 folder에 가서 다음 exe를 실행하면 된다.

  • d:\a\apps\gpt4all\bin\chat.exe 을 실행하면 아래창이 뜬다.

모델을 선택하라는 화면, download 하길 모델을 선택한다. 그림에도 있지만, Wizard v1.1 의 경우 최소 16GB 이상의 RAM 이 필요하다고 나온다. 여기서는 좀 더 가벼운 GPT4All Falcon 을 택한다.

모델선택 화면
model 을 선택안할때

GPT4All Falcon

  • download size : 3.78GB
  • RAM required : 8GB
  • parameters : 70억개
  • Quantization: q4_0

cpu 사용률은 확실히 높다. 거의 100%를 다 사용한다. gpu 로 돌릴 수 있는 쪽이 사용하긴 더 좋을 듯 하다. 어느수준까지 질문을 해야할지는 모르겠지만 답변은 나쁘지 않아보인다. local에서 chatgpt 같은 수준의 LLM 을 돌릴려면 충분할 듯 싶기도 하다. 앞단에 서버만 하나 만들어주면, local chatGPT 도 가능할 듯.

대화, cpu사용률

Reference

  1. GitHub - nomic-ai/gpt4all: gpt4all: an ecosystem of open-source chatbots trained on a massive collections of clean assistant data including code, stories and dialogue

[컴][머신러닝] LLM 관련 참고 링크들 from 구글내부 문서, 오픈소스 AI가 유리한 이유

 

구글내부 문서, 오픈소스 AI가 유리한 이유

LLM 관련 참고 링크들 from 구글내부 문서, 오픈소스 AI가 유리한 이유

대략적으로 이야기하면, 오픈소스 AI 가 여러 다양한 시도를 빠르게 하고, 다른 사람의 작업이 누적되기에 더 나은 결과를 빠르게 가져올 것이라 한다. 자세한 내용은 ref. 1을 보자.

여기서는 ref. 1에 나온 링크들을 정리했다.

링크

Reference

  1. Google “We Have No Moat, And Neither Does OpenAI”

[컴][머신러닝] stable diffussion Web UI

스테이블 디퓨젼 , 디퓨전 / 사용 / hw spec

stable diffussion Web UI

하드웨어 스펙

  • i5-9400F, 2.90GHz
  • 8GB x 2
  • Geforce GTX 1660, 8GB

실행

  1. python 3.10.6 설치
  2. git 설치
  3. v1.0.0-pre 를 download(sd.webui.zip)
  4. python path 추가: set PATH=d:\apps\Python\Python311;d:\apps\Python\Python311\Scripts;%PATH%
  5. update.bat
  6. run.bat

실행화면

d:\a\prog\stablediffusion\webui>update.bat
Updating 48a15821..baf6946e
Fast-forward
 .eslintignore                                      |    4 +
 .eslintrc.js                                       |   88 ++
 .git-blame-ignore-revs                             |    2 +
 .github/ISSUE_TEMPLATE/bug_report.yml              |   50 +-
 .github/pull_request_template.md                   |   33 +-
 .github/workflows/on_pull_request.yaml             |   49 +-
 .github/workflows/run_tests.yaml                   |   53 +-
 .gitignore                                         |    6 +-
 CHANGELOG.md                                       |  200 +++
 README.md                                          |   39 +-
 configs/instruct-pix2pix.yaml                      |   98 ++
 .../v1-inpainting-inference.yaml                   |   36 +-
 environment-wsl2.yaml                              |   10 +-
 extensions-builtin/LDSR/ldsr_model_arch.py         |   13 +-
 extensions-builtin/LDSR/scripts/ldsr_model.py      |   23 +-
 extensions-builtin/LDSR/sd_hijack_autoencoder.py   |   28 +-
 extensions-builtin/LDSR/sd_hijack_ddpm_v1.py       |   66 +-
 extensions-builtin/Lora/extra_networks_lora.py     |   27 +-
 extensions-builtin/Lora/lora.py                    |  392 +++++-
 extensions-builtin/Lora/scripts/lora_script.py     |   90 +-
 extensions-builtin/Lora/ui_extra_networks_lora.py  |   16 +-
 extensions-builtin/ScuNET/scripts/scunet_model.py  |   98 +-
 extensions-builtin/ScuNET/scunet_model_arch.py     |   11 +-
 extensions-builtin/SwinIR/scripts/swinir_model.py  |    9 +-
 extensions-builtin/SwinIR/swinir_model_arch.py     |    6 +-
 extensions-builtin/SwinIR/swinir_model_arch_v2.py  |   58 +-
 .../javascript/prompt-bracket-checker.js           |  130 +-
 html/extra-networks-card.html                      |    7 +-
 html/licenses.html                                 |  271 ++++
 javascript/aspectRatioOverlay.js                   |  226 +--
 javascript/contextMenus.js                         |  349 +++--
 javascript/dragdrop.js                             |   52 +-
 javascript/edit-attention.js                       |  216 +--
 javascript/extensions.js                           |  109 +-
 javascript/extraNetworks.js                        |  284 +++-
 javascript/generationParams.js                     |   48 +-
 javascript/hints.js                                |  122 +-
 javascript/hires_fix.js                            |   40 +-
 javascript/imageMaskFix.js                         |   26 +-
 javascript/imageParams.js                          |    5 +-
 javascript/imageviewer.js                          |  283 ++--
 javascript/imageviewerGamepad.js                   |   57 +
 javascript/localization.js                         |  341 ++---
 javascript/notification.js                         |   20 +-
 javascript/progressbar.js                          |  250 ++--
 javascript/textualInversion.js                     |   34 +-
 javascript/ui.js                                   |  497 ++++---
 javascript/ui_settings_hints.js                    |   62 +
 launch.py                                          |  339 +----
 models/karlo/ViT-L-14_stats.th                     |  Bin 0 -> 7079 bytes
 modules/Roboto-Regular.ttf                         |  Bin 0 -> 305608 bytes
 modules/api/api.py                                 |  373 +++--
 modules/api/models.py                              |   54 +-
 modules/call_queue.py                              |    6 +-
 modules/cmd_args.py                                |  109 ++
 modules/codeformer/codeformer_arch.py              |   24 +-
 modules/codeformer/vqgan_arch.py                   |   44 +-
 modules/codeformer_model.py                        |   10 +-
 modules/config_states.py                           |  202 +++
 modules/deepbooru.py                               |    3 +-
 modules/deepbooru_model.py                         |    4 +-
 modules/devices.py                                 |  114 +-
 modules/esrgan_model.py                            |   21 +-
 modules/esrgan_model_arch.py                       |   24 +-
 modules/extensions.py                              |   89 +-
 modules/extra_networks.py                          |   16 +-
 modules/extra_networks_hypernet.py                 |    9 +-
 modules/extras.py                                  |   73 +-
 modules/generation_parameters_copypaste.py         |  285 ++--
 modules/gfpgan_model.py                            |    7 +-
 modules/hashes.py                                  |   41 +-
 modules/hypernetworks/hypernetwork.py              |   49 +-
 modules/hypernetworks/ui.py                        |    6 +-
 modules/images.py                                  |  193 ++-
 modules/img2img.py                                 |   54 +-
 modules/interrogate.py                             |   17 +-
 modules/launch_utils.py                            |  334 +++++
 modules/localization.py                            |    4 +-
 modules/lowvram.py                                 |   10 +-
 modules/mac_specific.py                            |   63 +
 modules/masking.py                                 |    2 +-
 modules/memmon.py                                  |   12 +-
 modules/modelloader.py                             |   78 +-
 modules/models/diffusion/ddpm_edit.py              | 1455 ++++++++++++++++++++
 modules/models/diffusion/uni_pc/__init__.py        |    1 +
 modules/models/diffusion/uni_pc/sampler.py         |  101 ++
 modules/models/diffusion/uni_pc/uni_pc.py          |  863 ++++++++++++
 modules/ngrok.py                                   |   30 +-
 modules/paths.py                                   |   11 +-
 modules/paths_internal.py                          |   31 +
 modules/postprocessing.py                          |    9 +-
 modules/processing.py                              |  414 ++++--
 modules/progress.py                                |   34 +-
 modules/prompt_parser.py                           |   27 +-
 modules/realesrgan_model.py                        |   26 +-
 modules/safe.py                                    |   17 +-
 modules/script_callbacks.py                        |  114 +-
 modules/script_loading.py                          |   11 +-
 modules/scripts.py                                 |  171 ++-
 modules/scripts_auto_postprocessing.py             |   42 +
 modules/scripts_postprocessing.py                  |   21 +-
 modules/sd_disable_initialization.py               |   19 +-
 modules/sd_hijack.py                               |  153 +-
 modules/sd_hijack_clip.py                          |    2 +-
 modules/sd_hijack_clip_old.py                      |    3 +-
 modules/sd_hijack_inpainting.py                    |   20 +-
 modules/sd_hijack_ip2p.py                          |   10 +
 modules/sd_hijack_optimizations.py                 |  347 ++++-
 modules/sd_hijack_unet.py                          |   51 +-
 modules/sd_hijack_utils.py                         |   28 +
 modules/sd_hijack_xlmr.py                          |    2 -
 modules/sd_models.py                               |  395 ++++--
 modules/sd_models_config.py                        |  118 ++
 modules/sd_samplers.py                             |  527 +------
 modules/sd_samplers_common.py                      |   95 ++
 modules/sd_samplers_compvis.py                     |  224 +++
 modules/sd_samplers_kdiffusion.py                  |  392 ++++++
 modules/sd_vae.py                                  |   16 +-
 modules/sd_vae_approx.py                           |    5 +-
 modules/sd_vae_taesd.py                            |   88 ++
 modules/shared.py                                  |  478 ++++---
 modules/shared_items.py                            |   31 +
 modules/styles.py                                  |   23 +-
 modules/sub_quadratic_attention.py                 |   21 +-
 modules/textual_inversion/autocrop.py              |  214 +--
 modules/textual_inversion/dataset.py               |   62 +-
 modules/textual_inversion/image_embedding.py       |   28 +-
 modules/textual_inversion/learn_schedule.py        |    6 +-
 modules/textual_inversion/preprocess.py            |   31 +-
 modules/textual_inversion/textual_inversion.py     |   78 +-
 modules/timer.py                                   |   38 +
 modules/txt2img.py                                 |   19 +-
 modules/ui.py                                      |  605 +++++---
 modules/ui_common.py                               |   27 +-
 modules/ui_components.py                           |   52 +-
 modules/ui_extensions.py                           |  384 +++++-
 modules/ui_extra_networks.py                       |  244 +++-
 modules/ui_extra_networks_checkpoints.py           |   31 +
 modules/ui_extra_networks_hypernets.py             |   13 +-
 modules/ui_extra_networks_textual_inversion.py     |   14 +-
 modules/ui_loadsave.py                             |  210 +++
 modules/ui_postprocessing.py                       |   10 +-
 modules/ui_tempdir.py                              |   19 +-
 modules/upscaler.py                                |   14 +-
 modules/xlmr.py                                    |    8 +-
 package.json                                       |   11 +
 pyproject.toml                                     |   35 +
 requirements-test.txt                              |    3 +
 requirements.txt                                   |   10 +-
 requirements_versions.txt                          |   24 +-
 script.js                                          |   94 +-
 scripts/custom_code.py                             |   65 +-
 scripts/img2imgalt.py                              |   48 +-
 scripts/loopback.py                                |  100 +-
 scripts/outpainting_mk_2.py                        |    8 +-
 scripts/poor_mans_outpainting.py                   |    8 +-
 scripts/postprocessing_upscale.py                  |   73 +-
 scripts/prompt_matrix.py                           |   52 +-
 scripts/prompts_from_file.py                       |   20 +-
 scripts/sd_upscale.py                              |   10 +-
 scripts/xy_grid.py                                 |  498 -------
 scripts/xyz_grid.py                                |  720 ++++++++++
 style.css                                          |  920 ++++++-------
 test/basic_features/__init__.py                    |    0
 test/basic_features/extras_test.py                 |   54 -
 test/basic_features/img2img_test.py                |   66 -
 test/basic_features/txt2img_test.py                |   80 --
 test/basic_features/utils_test.py                  |   62 -
 test/conftest.py                                   |   17 +
 test/server_poll.py                                |   24 -
 test/test_extras.py                                |   35 +
 test/test_img2img.py                               |   68 +
 test/test_txt2img.py                               |   90 ++
 test/test_utils.py                                 |   33 +
 webui-macos-env.sh                                 |    4 +-
 webui-user.sh                                      |    3 +
 webui.py                                           |  415 ++++--
 webui.sh                                           |   68 +-
 178 files changed, 14062 insertions(+), 5792 deletions(-)
 create mode 100644 .eslintignore
 create mode 100644 .eslintrc.js
 create mode 100644 .git-blame-ignore-revs
 create mode 100644 CHANGELOG.md
 create mode 100644 configs/instruct-pix2pix.yaml
 rename v2-inference-v.yaml => configs/v1-inpainting-inference.yaml (61%)
 create mode 100644 javascript/imageviewerGamepad.js
 create mode 100644 javascript/ui_settings_hints.js
 create mode 100644 models/karlo/ViT-L-14_stats.th
 create mode 100644 modules/Roboto-Regular.ttf
 create mode 100644 modules/cmd_args.py
 create mode 100644 modules/config_states.py
 create mode 100644 modules/launch_utils.py
 create mode 100644 modules/mac_specific.py
 create mode 100644 modules/models/diffusion/ddpm_edit.py
 create mode 100644 modules/models/diffusion/uni_pc/__init__.py
 create mode 100644 modules/models/diffusion/uni_pc/sampler.py
 create mode 100644 modules/models/diffusion/uni_pc/uni_pc.py
 create mode 100644 modules/paths_internal.py
 create mode 100644 modules/scripts_auto_postprocessing.py
 create mode 100644 modules/sd_hijack_ip2p.py
 create mode 100644 modules/sd_hijack_utils.py
 create mode 100644 modules/sd_models_config.py
 create mode 100644 modules/sd_samplers_common.py
 create mode 100644 modules/sd_samplers_compvis.py
 create mode 100644 modules/sd_samplers_kdiffusion.py
 create mode 100644 modules/sd_vae_taesd.py
 create mode 100644 modules/shared_items.py
 create mode 100644 modules/timer.py
 create mode 100644 modules/ui_extra_networks_checkpoints.py
 create mode 100644 modules/ui_loadsave.py
 create mode 100644 package.json
 create mode 100644 pyproject.toml
 create mode 100644 requirements-test.txt
 delete mode 100644 scripts/xy_grid.py
 create mode 100644 scripts/xyz_grid.py
 delete mode 100644 test/basic_features/__init__.py
 delete mode 100644 test/basic_features/extras_test.py
 delete mode 100644 test/basic_features/img2img_test.py
 delete mode 100644 test/basic_features/txt2img_test.py
 delete mode 100644 test/basic_features/utils_test.py
 create mode 100644 test/conftest.py
 delete mode 100644 test/server_poll.py
 create mode 100644 test/test_extras.py
 create mode 100644 test/test_img2img.py
 create mode 100644 test/test_txt2img.py
 create mode 100644 test/test_utils.py
계속하려면 아무 키나 누르십시오 . . .

d:\a\prog\stablediffusion\webui>run.bat
Python 3.10.6 (tags/v3.10.6:9c7b4bd, Aug  1 2022, 21:53:49) [MSC v.1932 64 bit (AMD64)]
Version: v1.3.2
Commit hash: baf6946e06249c5af9851c60171692c44ef633e0
Installing torch and torchvision
Looking in indexes: https://pypi.org/simple, https://download.pytorch.org/whl/cu118
Collecting torch==2.0.1
  Downloading https://download.pytorch.org/whl/cu118/torch-2.0.1%2Bcu118-cp310-cp310-win_amd64.whl (2619.1 MB)
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 2.6/2.6 GB 2.2 MB/s eta 0:00:00
Collecting torchvision==0.15.2
  Downloading https://download.pytorch.org/whl/cu118/torchvision-0.15.2%2Bcu118-cp310-cp310-win_amd64.whl (4.9 MB)
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 4.9/4.9 MB 22.5 MB/s eta 0:00:00
Collecting filelock (from torch==2.0.1)
  Downloading filelock-3.12.2-py3-none-any.whl (10 kB)
Collecting typing-extensions (from torch==2.0.1)
  Downloading typing_extensions-4.6.3-py3-none-any.whl (31 kB)
Collecting sympy (from torch==2.0.1)
  Downloading sympy-1.12-py3-none-any.whl (5.7 MB)
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 5.7/5.7 MB 22.9 MB/s eta 0:00:00
Collecting networkx (from torch==2.0.1)
  Using cached networkx-3.1-py3-none-any.whl (2.1 MB)
Collecting jinja2 (from torch==2.0.1)
  Downloading https://download.pytorch.org/whl/Jinja2-3.1.2-py3-none-any.whl (133 kB)
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 133.1/133.1 kB ? eta 0:00:00
Collecting numpy (from torchvision==0.15.2)
  Downloading numpy-1.25.0-cp310-cp310-win_amd64.whl (15.0 MB)
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 15.0/15.0 MB 23.4 MB/s eta 0:00:00
Collecting requests (from torchvision==0.15.2)
  Using cached requests-2.31.0-py3-none-any.whl (62 kB)
Collecting pillow!=8.3.*,>=5.3.0 (from torchvision==0.15.2)
  Using cached Pillow-9.5.0-cp310-cp310-win_amd64.whl (2.5 MB)
Collecting MarkupSafe>=2.0 (from jinja2->torch==2.0.1)
  Downloading MarkupSafe-2.1.3-cp310-cp310-win_amd64.whl (17 kB)
Collecting charset-normalizer<4,>=2 (from requests->torchvision==0.15.2)
  Using cached charset_normalizer-3.1.0-cp310-cp310-win_amd64.whl (97 kB)
Collecting idna<4,>=2.5 (from requests->torchvision==0.15.2)
  Using cached https://download.pytorch.org/whl/idna-3.4-py3-none-any.whl (61 kB)
Collecting urllib3<3,>=1.21.1 (from requests->torchvision==0.15.2)
  Using cached urllib3-2.0.3-py3-none-any.whl (123 kB)
Collecting certifi>=2017.4.17 (from requests->torchvision==0.15.2)
  Using cached certifi-2023.5.7-py3-none-any.whl (156 kB)
Collecting mpmath>=0.19 (from sympy->torch==2.0.1)
  Using cached mpmath-1.3.0-py3-none-any.whl (536 kB)
Installing collected packages: mpmath, urllib3, typing-extensions, sympy, pillow, numpy, networkx, MarkupSafe, idna, filelock, charset-normalizer, certifi, requests, jinja2, torch, torchvision
Successfully installed MarkupSafe-2.1.3 certifi-2023.5.7 charset-normalizer-3.1.0 filelock-3.12.2 idna-3.4 jinja2-3.1.2 mpmath-1.3.0 networkx-3.1 numpy-1.25.0 pillow-9.5.0 requests-2.31.0 sympy-1.12 torch-2.0.1+cu118 torchvision-0.15.2+cu118 typing-extensions-4.6.3 urllib3-2.0.3
Installing gfpgan
Installing clip
Installing open_clip
Cloning Stable Diffusion into D:\a\prog\stablediffusion\webui\webui\repositories\stable-diffusion-stability-ai...
Cloning Taming Transformers into D:\a\prog\stablediffusion\webui\webui\repositories\taming-transformers...
Cloning K-diffusion into D:\a\prog\stablediffusion\webui\webui\repositories\k-diffusion...
Cloning CodeFormer into D:\a\prog\stablediffusion\webui\webui\repositories\CodeFormer...
Cloning BLIP into D:\a\prog\stablediffusion\webui\webui\repositories\BLIP...
Installing requirements for CodeFormer
Installing requirements
Launching Web UI with arguments:
No module 'xformers'. Proceeding without it.
Downloading: "https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/v1-5-pruned-emaonly.safetensors" to D:\a\prog\stablediffusion\webui\webui\models\Stable-diffusion\v1-5-pruned-emaonly.safetensors

100%|███████████████████████████████████████████████████████████████████████████████| 3.97G/3.97G [03:02<00:00, 23.4MB/s]
Calculating sha256 for D:\a\prog\stablediffusion\webui\webui\models\Stable-diffusion\v1-5-pruned-emaonly.safetensors: Running on local URL:  http://127.0.0.1:7860

To create a public link, set `share=True` in `launch()`.
Startup time: 190.6s (import torch: 1.8s, import gradio: 2.4s, import ldm: 0.5s, other imports: 1.9s, setup codeformer: 0.1s, list SD models: 182.4s, load scripts: 0.8s, create ui: 0.2s, gradio launch: 0.4s).
6ce0161689b3853acaa03779ec93eafe75a02f4ced659bee03f50797806fa2fa
Loading weights [6ce0161689] from D:\a\prog\stablediffusion\webui\webui\models\Stable-diffusion\v1-5-pruned-emaonly.safetensors
Creating model from config: D:\a\prog\stablediffusion\webui\webui\configs\v1-inference.yaml
LatentDiffusion: Running in eps-prediction mode
DiffusionWrapper has 859.52 M params.
Downloading (…)olve/main/vocab.json: 100%|████████████████████████████████████████████| 961k/961k [00:00<00:00, 1.62MB/s]
Downloading (…)olve/main/merges.txt: 100%|█████████████████████████████████████████████| 525k/525k [00:00<00:00, 890kB/s]
Downloading (…)cial_tokens_map.json: 100%|██████████████████████████████████████████████████████| 389/389 [00:00<?, ?B/s]
Downloading (…)okenizer_config.json: 100%|██████████████████████████████████████████████████████| 905/905 [00:00<?, ?B/s]
Downloading (…)lve/main/config.json: 100%|██████████████████████████████████████████████████| 4.52k/4.52k [00:00<?, ?B/s]
Applying optimization: Doggettx... done.
Textual inversion embeddings loaded(0):
Model loaded in 10.5s (calculate hash: 3.6s, load weights from disk: 0.1s, create model: 3.8s, apply weights to model: 0.6s, apply half(): 0.6s, move model to device: 0.9s, load textual inversion embeddings: 0.8s).
100%|████████████████████████████████████████████████████████████████████████████████████| 20/20 [00:07<00:00,  2.81it/s]
Total progress: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████| 20/20 [00:03<00:00,  6.61it/s]
100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 20/20 [00:03<00:00,  6.61it/s]
Total progress: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████| 20/20 [00:02<00:00,  7.03it/s]
100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 20/20 [00:03<00:00,  6.61it/s]
Total progress: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████| 20/20 [00:02<00:00,  7.05it/s]
100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 20/20 [00:05<00:00,  3.42it/s]
Total progress: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████| 20/20 [00:05<00:00,  3.39it/s]
100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 20/20 [00:02<00:00,  6.67it/s]
Total progress: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████| 20/20 [00:02<00:00,  6.69it/s]
Interrupted with signal 2 in <frame at 0x000001DD2E5D1170, file 'threading.py', line 324, code wait>██████████████████████| 20/20 [00:02<00:00,  7.08it/s]
일괄 작업을 끝내시겠습니까 (Y/N)? y

See Also

  1. How to use models · civitai/civitai Wiki · GitHub : <civitai.com> 에서 model을 받아서 local에서 사용해 볼 수 있다.

[컴] LLM 의 학습에는 pretraining 이 중요하다.

대규모 언어 모델

LLM 의 학습에는 pretraining 이 중요하다.

다음 글은 위의 내용을 정리 한 것이다.

Large Language Model(LLM) 들은 2가지 stage 를 거쳐서 학습하게 된다.

  1. general-purpose representations(범용 표현)을 배우기 위한, raw text 로 하는 ‘unsupervised pretraining’.
  2. ‘대규모 명령어 튜닝(large scale instruction tuning)’ 과 ‘강화학습(reinforcement learning)’ 을 통해 end tasks 와 사용자 선호도에 더 잘 일치하게 한다.(to better align)

‘강화학습’ 또는 ‘인간선호도에 대한 모델링’ 없이 LIMA 를 훈련해서, 이 2개의 step 중 어느것의 중요성이 더 높은지 확인하는 작업을 했다.

LIMA

standard supervised 학습을 하고 그 loss 로 응답이 미세조정된, 6500만 parameter의 LLaMa 언어모델

이 훈련된 LIMA 가 놀라운 성능을 보여줬다.

훈련 데이터(training data)에 있는 단지 몇안되는 예시들 통해서, 특정 응답 형식들을 따르는 법을 학습해서 놀라운 성능을 보여줬다. 이 훈련데이터는 ’여행 일정을 계획하는 것’에서부터 ’대체 역사를 추측하는 것’에 이르는 복잡한 질문들을 포함하고 있다.

통제된 사람들을 대상으로 한 연구에서 LIMA 로 부터나온 응답들은

  • GPT-4 에 비해 case의 43% 에서 동등하거나 더 선호되는 것으로 나타났다.
  • Bard 와 비교할 때는 58% 의 case 에서 동등하거나 더 선호됐고,
  • DaVinci003에서는 65% 의 case 에서 동등하거나 더 선호됐다.

이 결과들은 다음 사실을 강력히 시사한다.

  • LLM 의 거의 모든 지식들이 pretrainning 과정에서 학습(learn) 되고,
  • model 들이 고품질의 결과를 생산하도록 가르치기 위해서는 오직 제한된 명령어 튜닝 데이터(limited instruction tuning data) 만 있으면 된다는 것

[컴][머신러닝] AI 에서 autoencoder

 

머신러닝 / 오토인코더

AI 에서 autoencoder

autoencoder 의 목적은 network를 training을 통해서 높은 차원의 data를 좀 더 낮은 차원을 이용해서 표현(lower dimensinal representation)하는 것이다. 일반적으로 차원수를 낮추는 것이다.[ref. 1]

이 ‘lower dimensinal representation’ 을 encoding이라고도 하고, latent space라고도 한다.

encoder 를 해서 좀 더 낮은 차원을 이용해서 표현(lower dimensinal representation)하게 된다. 예를 들면, 3차원으로 표시된 점들을 2차원에 표시하는 것을 들 수 있다. 여러가지 방법이 있겠지만, 예를 들면, 3차원의 점 (1,2,3) 이 있다고 하면, 이것을 (1,2*3000000) 등으로 표현할 수 있다. 물론 겹치지 않도록 잘 조절해야겠지만.

여하튼, 이렇게 만들어진 값을 encoding 된 값으로 보고, 이런 값들의 집합이 latent space 가 된다. 그러면 여기서 시작해서 새로운 값을 만들어내게 되는데, 이것을 decoding 이라고 이야기 한다.

이것은 diffusion model 에서 이미지를 뭉갰다가 다시 거기서 새로운 이미지를 만들어내는 것을 생각해보면, 이해가 될 듯 하다.

3가지 부분

autoencoder 는 3가지 부분으로 구성된다.

  1. Encoder
    input data를 압축해서 인코딩된 표현으로(encoded representation)으로 만들어주는 모듈
  2. Bottleneck
    encoder에 의해 압축된 정보들을 가지고 있는 모듈이다.
  3. Decoder
    압축된 정보들을 다시 decompress 하고 데이터를 새롭게 구성한다.

References

  1. Autoencoders in Deep Learning: Tutorial & Use Cases [2023]

[컴][머신러닝] ChatGPT 의 동작에 대한 글, 번역

머신러닝/ ai / machine learning / openai

ChatGPT 의 동작에 대한 글, 번역

아래내용은 다음 링크의 글에 대한 번역과, 읽고 정리한 내용이 섞여있다. 개인적인 이해를 바탕으로 적어놓은 글이기에 틀린부분이 많이 있을 수 있다. 정확한 내용은 원문을 참고하자.

chatGPT 가 항상 본질적으로 하는 작업은 지금까지 만들어진 text의 ‘합리적인 이어짐’(resonable continuation)을 생성하는 것이다. 여기서 ’합리적인’이라는 것은 “수십억개의 웹페이지등에 작성한 것들을 본 이후 누군가가 쓸(write) 법한 것”이란 의미라고 한다.

me: 결론부분에도 나오지만 뭔가 그럴싸한 단어들을 계속해서 이어가는 것이 chatGPT 가 하는 일이라는 이야기로 해석해도 되지 않을까 싶다.

The best thing about AI is its ability to ?

라는 문장이 있을 때 ? 에 어떤 단어가 오면 좋을지에 대해 분석을 한다면, 인터넷에서 저 글이 들어간 모든 문장을 찾고, 그 다음에 어떤 단어가 왔는지 목록을 만드는 것이다. 그리고 얼마나 자주 단어가 나왔는지 빈도를 가지고 확률을 만들어낼 수 있다.

이것을 ChatGPT 는 매순간 한다. 즉, 단어(token 이 더 정확한 표현)가 추가될 때마다 이런 작업을 한다. 예를 들어 위의 예제에서 다음 단어가 ‘learn’ 으로 추가되면, 이젠 learn 다음에 어떤 단어가 나오면 좋을지를 알기위해서 ’The best thing about AI is its ability to learn’가 나온 모든 페이지들을 분석하는 작업을 한다는 것이다.

The best thing about AI is its ability to learn ?

이때 가장 높은 확률의 단어만 택하면, 그것은 항상 같은 문장이 되어 버린다. 그래서 여기에 어느정도 random 으로 단어를 선택하게 된다. 그래서 항상 다른 결과를 만들어내게 된다.

낮은 순위의 단어가 얼마나 자주 사용될 것인지를 결정하는 ‘온도’(temperature) parameter 가 있다. 에세이 생성은 0.8의 온도가 가장 좋은 것으로 나타났다. 왜 0.8이 좋은지에 대한 이론은 없다. 대체로 0.8을 사용할 때 가장 좋은 결과가 나왔다는 정도이다. 0 은 항상 가장 높은 확률의 단어를 택하는 것이다. 0.8 의 온도를 택하면, 선택지가 너무 많은 것은 아닐까 걱정되지만, 이것은 점점 단어(token) 이 쌓이면서, 그 다음에 나올 단어의 선택지의 폭이 대폭 줄어든다.(power-low decay)

아래 GPT2 Transformer 링크에서 직접 테스트 해 볼 수 있다. wolframcloud.com 에서 계정을 만들어서 사용해 보면 된다.

ChatGPT 는 확률에 따라 다음 단어를 선택하게 되어 있는데, 그러면 이 확률은 어떻게 구하는가? 예를 문자하나, 즉 a, b, c, … 등이 문장에서 얼마나 많이 나오는가를 구해 볼 수 있다. 표본이 커질수록 각 문자하나(character) 가 나오는 확률은 특정값에 가까워질 것이다. 그래서 나온 확률이 만약 다음과 같다고 해보자.(ref. 1 에서 )

  • e가 나올 확률: 12.7%
  • i가 나올 확률: 6.97%

그런데 이 개별 character 의 확률을 가지고는 단어가 만들어질 수 없다. 그래서 현재문자(character) 다음에 올 문자의 확률을 구하는 작업을 한다.

즉 모든 word 들을 조사해서 a 다음에 a 가 나올 확률, b 가 나올확률, … 등을 모든 2-grams(2개의 연속되는 것들이 모여있는 것) 의 확률을 구하는 것이다.

그러면 좀 더 단어(word) 에 가까워진다. 즉, 좀 더 긴 n-gram 에 대한 확률을 구해놓으면, 더 나은 모양의 단어(word) 를 만들 수 있다. 즉 컴퓨터가 다음에 뭐가 나와야 word 가 되는지를 알 수 있게 되는 것이다.

하지만 이것만 가지고는 문장을 만들기가 어렵다. 그래서 word 에 대한 n-gram 에 대한 확률을 구해야 한다. 즉, 어떤 단어뒤에 어떤 단어가 올 때 문장이 되는가를 컴퓨터가 알 수 있도록, 모든 text 들을 뒤져서 특정단어뒤에 어떤 단어들이 나오고, 그 단어가 얼마나 자주 나오는지를 구해놓는 것이다. (n-gram of words 의 확률을 구하는 것이다.)

영어는 대략 40,000개의 단어가 주로 쓰인다고 한다. 그런데 이 단어의 2-gram 만 되어도 이미 16억개(4만x4만) 이고, 3-gram 의 수는 60조개이다. 결국 문장을 만들기 위해 n-gram 의 확률을 구하는 것은 거의 불가능하다.

그래서 방법을 달리했다. 즉 모든 단어에 대해 앞으로 나올 확률을 계산하는 것이 아니라, 단어의 순서들(sequences)이 어떤 식으로 발생해야만 하는지에 대한 확률을 추정할 수 있는 model 을 만든 것이다.

me: 이것은 ’알파고’를 생각해보면 이해할 수 있다. 바둑도 그 바둑돌을 놓는 방법이 너무 많아서 계산을 해볼 수 없었다. 그래서 체스와 달리 컴퓨터가 인간을 이기기 쉽지 알았다. 하지만 ’알파고’는 방법을 달리했다. 현재 나와있는 ’기보’들을 공부하게 했다. 그래서 그 기보를 바탕으로 어떤 식으로 바둑돌을 놓는 것이 좋은지를 추정할 수 있는 식(model)을 만들것이다. 이 LLM(large language model) 도 비슷한 idea 를 적용했다고 보면 될 듯 하다.

모델(model)없는 모델은 없다는 것을 이해해야 한다.(me: 모든 모델은 특정 모델을 기본으로 잡고 시작한다는 뜻인듯) 모든 모델은 특정한 기본 구조가 있다. 그리고 여기에 데이터에 맞게 ‘돌릴 수 있는 손잡이(knob)’(즉, 설정할 수 있는 매개변수)가 있다. ChatGPT의 경우, 많은’knob’가 있고, 1,750억 개에 달한다.

그런데, 놀라운 점은 단순히 많은 parameter들만 가지고 있는 ChatGPT 의 기본 구조만으로도, ’다음 단어의 확률을 충분히 만족스럽게 계산할 수 있는 model’을 만들 수 있고, 그것으로 에세이 길이의 합리적인 text 를 제공할 수 있다는 점이다.

수학적으로, 논리적으로 사람이 이런 식으로 인식한다. 그것은 이런 수학공식을 사용해서 설명이 되고, 그런 이유로 이 model 이 동작하는 것이다. 라는 식으로 이 모델은 만들어지지 않는다. 그 이유는 사람이 어떤 식으로 인식하는지에 대한 수학적 모델이 없기 때문이다. 사람의 인식은 어느정도 주관적인 부분도 있다. 2라는 그림에서 몇개의 픽셀을 이상한 위치에 배치한다고 해도 사람은 대체로 2로 인식할 것이다. 하지만, 그것은 사람마다 다를 수 있고, 사람이 아닌 다른 동물이라면 다르게 해석할 수 있다. 그렇기에 이것을 수학적으로 증명하는 것은 쉽지 않다.

그래서, 단순히 어떤 수식(model) 의 결과가 사람이 판단하는 것 또는 말하는 것과 일치한다면, ’좋은 모델’을 가지고 있다고 판단하는 것이다. 좀 과장해서 이야기하면, 어떤 그럴싸한 로직이 있는 coding 을 하는 것이 아니라, 그저 모든 현상에 대한 if 문을 적용한 프로그램이 있다고 볼 수 있다.

신경망

신경망(neural net) 이라 불리는 것은 4개의 core layer들을 여러번 사용해서 11개 layer를 거친다. 이 신경망이 ‘사람이 판단하는 것같은, 사람이 말하는 것과 같은 model’ 을 수학적으로 구현해 준다. 이것이 이론적으로 도출된 것은 없으며, 1998년 공학적으로 작동하는 것으로 밝혀졌을 뿐이다.

그럼 신경망은 어떻게 사물을 인식할까? notion of attractors이 신경망의 핵심이다.

인식(recognition)이라는 것은 결국 구분이다. 하나의 사각형을 반으로 나누고, 1이 들어오면 왼쪽에, 2가 들어오면 오른쪽에 놓는다고 해보자. 1이라는 써여있는 희미한 글자가 들어올때, 우리는 그 글자가 1이 있는 왼쪽에 들어가게 하고, 2라는 희미한 글자가 있을 때 그것이 오른쪽 영역에 들어가게 한다. 그러면, 우리는 비슷한 모양들이 들어올때 1과 2를 구분지을 수 있게 된다. 즉, 왼쪽에 있는 것들은 1로 인식하게 되고, 오른쪽에 있는 것들은 2로 인식할 수 있게 된다. 즉, 우리는 어떤 사물을 한 영역으로 몰아서 넣을 수 있다면, 우리는 그것을 구분한다고 볼 수 있다.

하나의 다른 예를 가지고 이야기해보자. 사각형을 임으로 나누고, (x, y) 라는 값이 들어올때 이 값이 어느 부분에 속하는지를 파악한다고 해보자.

신경망은 여러개의 node 로 구성됐다. 그 node들이 한방향으로 흘러간다. 하나의 node 의 output 은 다른 node의 input 으로 들어간다. 그리고 다른 node 의 output 을 input 으로 받을 때는 각 node마다 다른 가중치를 준다. 이런식으로 여러개의 layer 를 거치게 된다.

node 에서 input x 를 받을 때 하는 일을 수식으로 나타내면, 아래처럼 x라는 input 이 오면, 거기에 가중치(w) 를 주고, 상수 b 를 더한다. 이 값에 thresholding function (또는 activiation function) 을 대입하게 된다.

 f[w . x + b],

w . x + b을 계산하는 것은 단순히 행렬에 대한 곱하기, 더하기 이다. ’activation function’은 비선형성을 가져온다. 그래서 궁극적으로 이것이 nontrivial 행동을 만들어내게 된다. 다양한 activation function들이 일반적으로 사용된다.

우리가 신경망이 수행하길 원하는 각 task 에 대해서 우리는 여러 가중치들(weights)을 갖게 된다. 이러한 가중치들은 일반적으로 신경망을 ’훈련’함으로써 결정된다. 이 신경망의 훈련은 우리가 원하는 출력들을 이용한 머신러닝을 통해서 이뤄진다.

우리가 알 수 있는건 각 신경망의 layer 마다 어떤 결과를 보여준다를 알 수 있다. 즉, ‘고양이’ 이미지를 찾는 중간중간의 결과물은 확인할 수 있지만, 이것이 왜 이런 과정을 거치면, 고양이를 찾을 수 있는지는 모른다. 그냥 그것이 잘 동작하기에 사용하는 수준이다.

이것은 ChatGPT 도 마찬가지다. 다만 ChatGPT 는 그것이 보여주는 중간단계가 ’언어’와 관련돼 있어서, 우리들이 그 중간 중간의 layer 의 결과를 통해 더 많은 insight 를 얻을 수 있을 수 있다.

신경망(neural net)들이 유용한 이유는 모든 종류의 일을 할 수 있다는 것만이 아니라, 그들이 ’예시’들에 의해 훈련되어서 그런 task들을 할 수 있게 되는 것이다.

그럼 neural net training 은 실제로 어떻게 동작할까?

우리는 항상 가중치들(weights)를 찾기위해 노력하는 것이다. 이 가중치들은 neural net 이 우리가 준 예시들을 성공적으로 재현하도록 만들어준다. 그러고 난후, 합리적인 방법으로 이 예시들 사이에서 interpolate (또는 generalize, 일반화) 하기 위해 신경망에 의존한다.

간단한 함수를 learn 하는 neural net 을 만든다고 해보자.

이 함수 모양과 비슷한 것을 얻기 위한 neural net 이 있는데, 이것의 가중치를 random 으로 할당해서 결과를 뽑아보자. 우리가 원하는 모양의 함수모양을 얻을 수 없다.

많은 “input –> output” 예시들을 제공해서 그것으로부터 배우라고 하고 싶다. 그러러면, 이 많은 예시들을 통해서 가중치를 조정해 나갈 수 있어야 한다.

이 훈련의 각 단계(stage) 에서 network 안의 가중치(weights)는 점진적으로 조정되며, 결국 우리가 원하는 기능을 성공적으로 재현할 수 있는 network 를 얻게 된다.

가중치 조정은 어떻게 할까? 기본적인 idea 는 각 stage 마다 우리가 원하는 기능으로 부터 “얼마나 멀리 떨어져 있는지”를 확인하고, 더 가까워질 수 있도록 weight들을 업데이트하는 것이다.

“얼마나 멀리 떨어져 있는지”를 알아내기 위해 “loss function”(또는 cost function) 이라는 것을 계산한다. 간단한 loss function 의 예를 들면, 우리가 원하는 함수 그래프의 위치에서 현재 그래프의 위치까지의 거리를 제곱, 즉 실제로 얻은값과 우리가 계산해서 얻은 값과의 차이의 제곱의 합을 이용할 수 있다. 이 손실함수 값이 학습이 진행돼서 가중치가 수정될 수록 줄어드는 것을 볼 수 있다.(ref. 1 의 그림 참고)

신경망들을 이용하면, 복잡한 문제들을 푸는것이 간단한 문제를 푸는 것보다 더 간단하다. 가중치가 여러개가 있어야 ‘최소치’(minimum) 로 이끄는 많은 다른 방향이 존재하기 때문이다. 가중치가 적으면 다른 곳으로 갈 수 없는 local minimum 에 갇히게 된다.

함수에 영향을 주는 요소를 많이 파악할 수록, 즉 이 함수에 적용되는 많은 변수를 알 수록 더 정확한 함수를 얻을 수 있다고 이야기하는 것 같다. 우리가 날씨를 예측할 때도, 날씨에 영향을 주는 많은 요소를 동시에 고려할 수 있어야 더 정확한 날씨를 예측할 수 있는것과 같다.

비슷한 성능을 보여주는 다양한 가중치 모음들(collections of weights) 이 있다. 실질적인 neural net 훈련에서는, 다르지만 비슷한 해결책들로 인도하는 많은 random 한 선택들이 있다. (그림 참고)

그림에서 보듯이 비슷하지만, 조금씩 다르다. 이 그래프들의 양끝단을 확장해서 볼때, 그래프가 완전히 달라 보일 수도 있다. 하지만 좁은 범위에서 저 그래프들은 다 같은 답을 가져다 준다. 즉, 관찰된 데이터와 일치(‘consistent with the observed data’) 한다.

신경망 학습의 핵심은 주어진 훈련 예시들을 가장 잘 포착할 수 있는 가중치(weights)들을 결정하는 것이다.

미래에 neural net들을 훈련하는 더 나은 방법이 나올 것이라 본다. 신경망들(neural nets)의 기본 아이디어는 구분되는 큰 수의 간단한 구성요소들에서 유연한 ‘computing fabric’ 을 만드는 것이다. 그리고 예시들로 부터 점차적으로 수정되어질 수 있는 fabric 을 만드는 것이다. 현재의 neural net들에서는 점진적 수정(incremental modification) 을 위해서, 필수적으로, 실수들이 적용된 미적분학의 개념들을 사용한다.

그런데 점차 높은 정확도의 숫자들은 문제가 되지 않는 것이 명확해 지고 있다. 현재 방법들에서는 8 비트 또는 더 낮은 값으로도 충분할 수 있다.

기본적으로 현재의 신경망들은 치명적인 한계가 있다. 각 예시 batch들의 효과들이 다시 weight들을 update 하는 곳으로 보내져서 처리된다. 그렇기에 신경망 훈련은 기본적으로 순차적(sequential) 이다. 실제로, 현재 컴퓨터 하드웨어는 신경망 훈련중 대부분의 시간동안 idle 상태에 있고, 한번에 한부분만 업데이트 된다. 이것은 현재 컴퓨터의 메모리가 CPU(또는 GPU) 와 분리돼 있기 때문이다. 이부분에 대한 개선의 여지도 있다.

인간의 것을 할 수 있게 됐지만, 이것이 모든 계산적인 한계를 넘었다는 것은 아니다. 많은 계산을 해야만 하는 것은 정복하지 못했다. 현재 인간이 할 수 있는 것들을 하게 된 것은 그것이 생각보다 계산을 적게하는 것이었다는 것을 발견했기 때문이다.

embedding 은 높은 차원의 input (high-dimentsional input)을 좀 더 낮은 차원의 vector로 변경하는 것을 이야기한다.(참고) 이것이 ChatGPT 에서는 ‘단어’(words)를 neural-net 에 친숙한 ‘숫자들의 모음’(collections of numbers)들로 방법을 바꾸는 방법을 이야기 한다고 볼 수 있다. 이것은 ’단어’에만 해당하지 않는다. sequence of words 를 collections of numbers 로 변경할 수도 있고, text 의 전체 block 을 collection of numbers 로 변경할 수도 있다. 이것이 ChatGPT 내부에서 이것들을 다루는 방식이다.

ChatGPT 는 text 를 가지고 와서, 그것을 표현할 수 있는 embedding vector를 만든다. 그리고 나서 그것은 목표는 다음에 나올 것 같은 다른 token들의 확률들을 찾는 것이다. 그리고 그것은 그것의 대답을 숫자들의 list 로 표현한다.

ChatGPT 내부

Transformer 는 글 한꼭지를 구성하는 token sequence 에 대해 어느정도 유사한 작업을 한다.그런데 여기에 attention 이라는 개념을 도입해서, sequence 의 일부에 다른 부분보다 더 많은 attention 을 기울이는 개념을 도입했다.

ChatGPT 가 실제로 하는 일은 현재 구성된 글을 합리적인 방법으로 이어가는 것이다.

3가지 기본 단계를 수행한다.

  1. 지금까지의 글에 해당하는 token sequence를 가져오고, 이에 해당하는 embedding(즉, 숫자배열)을 찾는다.
  2. 새로운 embedding(즉, 새로운 숫자 배열)을 생산하기 위해 이 embedding 에서 작업한다.
    • 이 작업은 표준 신경망 을 사용하고.
    • 네트워크에 있는 연속된 레이어들로 퍼져나가는 값들을 이용한다.
  3. 그런 다음 이 배열의 마지막 부분을 가져와서 약 5만개 값들의 array 을 생성한다. 그리고 이 생성한 array 가 ’다른 가능한 다음 token들’에 대한 확률들로 변환한다.

중요한 점은 이 pipeline 의 모든 부분이 신경망(neural network)에 의해 구현되며, 이 신경망의 가중치(weights) 들은 네트워크의 end-to-end training 에 의해 결정된다는 점이다. 즉, 전체 아키텍쳐를 제외하고는 명시적으로 설계된 것이 없으며(explicitly engineered), 모든 것이 그냥 학습된다.

(me: 그냥 이렇게 저렇게 해보니 되는것이지, 논리적으로 이것을 짜서 만드는 개념이 아니다.)

하지만 아키텍처가 set up 되는 방식에는 모든 종류의 경험과 신경망 지식(lore)을 필요로 하는 세부사항(details)들이 있다.

그래서 이 details 가 뭔지를 알아보자.

  1. embedding module

신경망은 여러개의 layer 로 구성되어 있고, 이 layer 안에는 neuron 이 있다. 이 neuron 이 computational element 이다.

GPT-2 에 대한 Wolfram Language 표현의 도식을 보면,

<도식> : https://content.wolfram.com/uploads/sites/43/2023/02/sw021423img86.png

input 으로 n개의 token 으로 된 vector 1개가 들어오면, 이것이 한 신경망을 거쳐서 embedding vector 로 변환되고, 다른 신경망으로 또 보내져서 ’위치들의 sequence’를 가지고, 그것으로 부터 다시 embedding vector 를 뽑아낸다. 그리고 이 2개의 embedding vector 를 합치는 작업을 한다.

왜 이런 작업들을 하는지에 대한 과학적 이유는 없다. 그저 다양한 시도를 해봤고, 이것이 잘 작동하는 것이라서 이것을 사용하는 것이다. 설정한 값이 대략적으로 맞다면, 계속 훈련(training)해서 값을 좀 더 정교하게 맞춰갈 수 있다. 이 때 굳이 신경망이 어떻게 그리고 왜 이렇게 구성되었는지 이해할 필요가 없다. 이것이 신경망의 비법(lore)이다.

Embedding ?
embedding 은 수학에서 한 위상공간에서 다른 위상공간으로 ’동상사상’하는 것을 이야기한다고 한다. 이것은 말이 어려운데, 쉽게 예를 든다면, 지도에 있는 Stereographic projection 방법이 있다. 이것은 3차원의 ’지구’를 2차원으로 표현한 방법이다. 이런것이 embedding 의 한 예다. - Stereographic projection - the basics - Geological Digressions

embdding module 다음에, transformer 의 main event 인 ’attenion block들의 sequence’가 시작된다. 이 attention block 개수가 GPT-3 에서는 96개, GPT2 는 12개이다.

GPT2 의 attention block 한개를 표현한 도식이 아래이다.

<도식> : https://content.wolfram.com/uploads/sites/43/2023/02/sw021423img88.png

각 attention block 안에는 attention head들의 collection 이 있다. 이 attention head 가 GPT2 에서는 12개 GPT3 에는 96개가 있다. 각각은 embedding vector 안의 서로 다른 값들의 덩어리와 함께 독립적으로 동작한다. 우리는 왜 이 embedding vector 를 분리하는 것이 좋은 이유인지는 모른다. 그리고 그것의 각부분들이 의미하는 바를 알지 못한다. 이는 그저 ’동작하는 것으로 밝혀진’것 중 하나라서 쓰는 것이다.

그럼 attention head 가 하는 일은? 그것들은 token들의 sequence 에서 looking back 하는 방법이며, 다음 token 을 찾기 쉬운 모양으로 과거를 packing up 하는 방법이다. 위의 첫 번째 섹션에서는 2그램의 확률을 이용해 바로 앞의 단어를 기반으로 단어를 선택하는 방법이 있었다. transformer의 ‘attention’ 메커니즘은 훨씬 앞의 단어에도 ‘attention’(주의) 를 기울일 수 있도록 하는 것이다. 예를 들어 동사는 한문장 내에서 ’많은 단어들이 앞에 나오는 명사(noun)’들을 언급할 수 있게 된다.

me: 이것의 다른 예를 든다면, copilot 을 보자, 만약 내가 특정 site 에 request 를 하는 curl 이 필요하다고 하자. 그저 단순하게 앞의 글자에 따라서 뒷글자를 뽑아낸다면, 다음처럼 url 을 뽑아내는 순간에, 바로 뒤의 값만 보고는 어떤 url 을 제안해야 할 지 알 수 없다. 이 때 comment 를 포함한 전체 문장에 대해, 다음에 나오는 모든 token 을 확인하고 그 중 가장 높은 확률을 가져오는 것은 많은 연산을 필요로 한다. 그리고 앞에서 언급했지만, 그것이 좋은 결과일지는 알 수 없다. 대신에 attention 을 통해서 looking back 을 해서, 어느정도 합리적인 수준으로 다음 token 을 이어갈 수 있게 된다.

# request to the naver openapi
curl -X GET "https://openapi.naver.com/v1/papago/n2mt" \

좀 더 자세한 레벨에서 보면, attention head 는 ’서로 다른 token들과 관련된 embedding vector들’안있는 chucnk 들을 특정 weight 들을 이용해서 다시 묶는다.

attention head들에 의해 처리가 끝나면, ’re-weighted embedding vector’는 standard “fully connected” neural net layer 를 통과한 것이 된다. 이 layer가 무엇을 하는지는 알기 어렵다.

이 가중치 행렬(matrix of weights)를 보면, 어떤 구조가 보인다. 이 구조를 결정하는 것은 아마도 ‘인간언어’에 대한 ’neural net encoding’ 일 것이다. 하지만 현재는 그 특징이 알려져있지 않다. 즉, 우리는 신경망을 열어서 이 신경망이 복잡하구나를 알았지만, 이 신경망을 이해하지는 못하고 있다. 그것이 인간과 비슷한 언어를 생성하는구나 정도만 알고 있다.

하나의 attention block 을 지나간 이후에, 하나의 새로운 embedding vector 를 갖은 상태가 된다. 이 embedding vector 가 순차적으로 추가적인 attention block들을 지나가게 된다. GPT-2 에서는 attention block이 12개이다. 각각의 attention block 은 각자의 attetion pattern 이 있고, fully connected weights 가 있다.

도표를 보면, 가중치 행렬들(matrices of weights)은 매우 유사해 보이지만, 가중치 크기의 다소 다를 수 있다.

이 attention block 들을 전부 통과하고 난후 트랜스포머의 net effect 는 ‘token sequence 에 대한 ebeddings 의 original collection’ 을 최종 collection으로 변환하는 것이다. ChatGPT 가 동작하는 방식은 이 최종 collection 에서 last embedding 을 뽑고, 그것을 decode 한다. 이것을 decode하는 이유는 ‘다음에 올 token’ 에 대한 확률목록을 생성하기 위해서다.

이것이 ChatGPT 내부를 개략적으로 설명한 것이다. 실제로 관련된 궁극적인 요소는 간단하다. 우리가 다루고 있는 것은 인공 뉴런들로 구성된 신경망이다. 이 각각의 인공뉴런은 숫자 입력들의 collection 을 가지고, 그것을 특정 weight들과 결합하는 간단한 작업을 한다.

튜링머신을 보면, 동일한 computational element 가 하나있고, 모든 것이 이것들에 의해 반복적으로 처리된다. 하지만 이 신경망은 적어도 주어진 출력토큰을 생성할때 각 computational element(즉, 뉴론)은 한번만 사용된다. 하지만 여전히 outer loop 이 존재한다. ChatGPT가 새로운 token 을 생성할 때는 항상 이전의 전체 token sequence를 input 으로 사용 한다.(ChatGPT 가 작성한 것을 포함한) 우리는 그래서 이러한 setup 이 ChatGPT 가 feedback loop 을 한다라고 생각할 수 있다.

ChatGPT 가 새로운 token 한개를 만들때마다 이 모든 weight들을 포함한 계산을 해야만 한다는 것이다. 구현적으로 이런한 계산은 layer에 의해 높은 병렬 array operation 들로 조직화될수 있다.(organized) 이 병력 작업들은 GPU들에서 편리하게 수행될 수 있다. 그러나 생성되는 각 token 에 대해 여전히 1750억번의 계산들을 해야만 한다.(끝에는 좀 더 많다.) 그래서 ChatGPT 가 긴 글을 생성하는데 시간이 걸리는 것은 당연할 수 밖에 없다.

What Really Lets ChatGPT Work?

어떻게 ChatGPT 가 언어와 관련해서 이만큼 올 수 있었을까? 내 생각에 근본적인 답은 그것은 언어가 근본적인 수준에서 생각보다 단순하다는 것이다. 그리고 이것이 뜻하는 바는 ChatGPT 는 성공적으로 인간언어와 그리고 그 이면의 사고(thinking)에 대한 본질(essence)을 포착할 수 있다는 것이다. 심지어 그것은 근본적으로 복잡하지 않은(straightforward) 신경망 구조를 가지고 있지만 말이다. 그리고 추가로, 그것의 학습에서, ChatGPT 는 이것을 가능하게 하는 언어와 사고에 있는 규칙을(그것이 무엇이든지) 어떻게든 암묵적으로 발견한(‘implicitly discovered’) 상황이다.

ChatGPT의 성공은 과학의 근본적인 그리고 중요한 부분에 대한 증거를 우리에게 준다고 생각한다. 즉, 우리가 새로운 언어의 법칙, 실질적으로 ‘사고의 법칙’ 을 발견하는 것을 기대할 수 있음을 시사한다. 신경망처럼 구축된 ChatGPT 에서 이런 ’법칙’들은 기껏해야 암묵적으로 존재한다. 그러나 우리가 어떻게든 그 법칙들을 명시적으로(explicit) 만들수 있다면, ChatGPT가 하는 일들이 더 직접적이고, 효율적으로, 그리고 투명한 방법으로 수행할 수 있게되는 가능성을 갖게 될 것이다.

ChatGPT의 기본 개념은 어느 수준에서는 다소 간단하다. 웹, 책 등에서 사람이 만든 방대한 텍스트 샘플에서 시작합니다. 그런 다음 신경망을 훈련시켜 텍스트 샘플처럼 생긴 텍스트를 생성합니다. 특히 ‘prompt’에서 시작할 수 있고, ’학습된 것과 같은’ 텍스트를 계속 생성할 수 있도록 만들어야 한다.

지금까지 살펴본 바와 같이 ChatGPT의 실제 신경망은 매우 단순한 elements(요소들)로 구성되어 있다.(비록 그 수가 수십억개이지만.) 그리고 신경망의 기본 작동도 매우 단순하다. 근본적으로, 새로운 단어(또는 단어의 일부)가 생성될 때마다, ’지금까지 생성된 텍스트에서 끌어내진 입력(input)’을 그것의 elements로 한번씩 전달하는 것으로 구성된다.(loop 없이)

하지만 놀랍고 예상치 못한 점은 이 프로세스를 통해 웹이나 책 등에 있는 것과 성공적으로 ‘비슷한’ 텍스트를 생성할 수 있다는 것이다. 또한 일관된 인간 언어일 뿐만 아니라 ‘읽은’ 콘텐츠를 활용하여 ‘prompt에 따라’ ‘무엇인가를 말한다’. 그것은 항상 “전체적으로 말이 되는”(또는 올바른 계산에 해당하는) 말을 하는 것은 아니다.(또는 정확한 계산들에 적합한) 왜냐하면(예를 들어 Wolfram|Alpha의 “계산 능력”에 액세스하지 않고) 그것은 그냥 훈련 자료에 있는 내용을 기반으로(what things “sounded like” in its training material) “그럴싸하게 들리는”(sound right) 내용을 말하기 때문에 말하기 때문이다.

ChatGPT의 특정 엔지니어링은 chatgpt를 상당히 매력적으로 만들었다. 하지만 궁극적으로 (적어도 외부 도구를 사용할 수 있을 때까지는) ChatGPT는 축적된 “통념의 통계”에서 “일관된 텍스트의 실”을 “단지” 뽑아내는 것에 불과합니다. 하지만 그 결과가 얼마나 인간과 유사한지 놀랍다. 그리고 앞서 설명했듯이 이것은 적어도 과학적으로 매우 중요한 사실을 시사한다. 즉, 인간의 언어(와 그 이면에 있는 사고 패턴)는 우리가 생각했던 것보다 그 구조가 더 단순하고, “법칙과 같다”는 것입니다. ChatGPT는 이를 암묵적으로 발견했습니다. 하지만 우리는 앞으로 잠재적으로 이를 의미론적 문법, 계산 언어 등을 이용해서 명시적으로 드러낼 수 있다

ChatGPT가 텍스트를 생성할 때 수행하는 작업은 매우 인상적이며, 그 결과는 일반적으로 인간이 생성하는 것과 매우 유사하다. 그렇다면 ChatGPT가 뇌처럼 작동한다는 뜻일까? 기본 인공 신경망 구조는 궁극적으로 뇌를 이상적으로 모델링한 것이다. 그리고 인간이 언어를 생성할 때 일어나는 일의 많은 측면이 매우 유사할 가능성이 높다.

훈련(일명 학습)과 관련하여 뇌와 현재 컴퓨터의 서로 다른 “하드웨어”(그리고 아마도 아직 개발되지 않은 알고리즘 아이디어)로 인해 ChatGPT는 뇌와 다소 다른 (그리고 어떤 면에서는 훨씬 덜 효율적인) 전략을 사용하게 된다. 그리고 또 한 가지, 일반적인 알고리즘 계산과 달리 ChatGPT는 내부적으로 “루프”나 “데이터에 대한 재계산”을 하지 않는다. 이는 필연적으로 계산 능력을 제한할 수밖에 없는데, 이는 현재의 컴퓨터와 비교했을 때도 그렇지만 뇌와 비교했을 때도 마찬가지이다.

이 문제를 ’해결’하면서도 합리적인 효율로 시스템을 훈련할 수 있는 능력을 유지하는 방법은 명확하지 않다. 하지만 그렇게 함으로써 미래의 ChatGPT는 아마도 훨씬 더 많은 “뇌와 같은 일”을 할 수 있을 것이다. 물론 두뇌가 잘 하지 못하는 일들, 특히 환원 불가능한 계산과 관련된 일들이 많이 있다. 그리고 이러한 두뇌와 ChatGPT와 같은 것들은 Wolfram 언어와 같은 “외부 도구”를 찾아야 한다.

그러나 현재로서는 ChatGPT가 이미 무엇을 할 수 있는지 보는 것이 흥미롭다. 어떤 수준에서는 많은 수의 간단한 계산 요소가, 놀랍고 예상치 못한 일을 할 수 있다는 근본적인 과학적 사실을 보여주는 좋은 예이다. 그러나 그것은 또한 아마, 2천 년 동안 우리가 가지고 있던 자극중 가장 좋은 자극을 제공한다.

그것은 또한 2천 년 동안 우리가 가지고 있던 최고의 자극을 제공했을 것이다. 이 자극을 통해 우리는 ’인간 조건의 중심 특징인 인간의 언어’와 그 이면에 있는 사고 과정들의 ’근본적인 특성과 원리’가 무엇인지 더 잘 이해하고 싶어 하게될 것이다.

[컴][머신러닝] 외부data 를 openapi 가 익히도록 해서 답변하도록 하기

 

ai / 머신러닝 / LLM / 언어모델 / 오픈api / 챗gpt /chatgpt / gpt code / code ai  / analyze code / source code github

외부data 를 openapi 가 익히도록 해서 답변하도록 하기

설치

pip install llama-index

git clone https://github.com/jerryjliu/gpt_index.git
cd gpt_index/examples/paul_graham_essay

paul_graham_essay 폴더에 가면 data 가 있다. 이 data 를 보면, paul_graham_essay.txt 가 있다. 간략하게 설명하면, 이 .txt를 OPENApi 에게 던져주고, 그것을 기반으로 대답을 하도록 하게 해주는 것이다.

이렇게 얻은 index 는 저장할 수 있다. index.save_to_disk()

다음처럼 .py 를 만들자.

from llama_index import GPTSimpleVectorIndex, SimpleDirectoryReader

documents = SimpleDirectoryReader('data').load_data()
index = GPTSimpleVectorIndex(documents)
# load from disk
# index = GPTSimpleVectorIndex.load_from_disk('my-index.json')

response = index.query("What did the author do growing up?")
print(response)

# save to disk
index.save_to_disk('my-index.json')

그리고 OPENAI_API_KEY 를 환경변수로 설정해주자. 그리고 code를 실행하면 된다.

SET OPENAI_API_KEY=sk-myopenapikey
python run.py

요즘의 chatGPT 를 이용한 tool들

실제로 하는 일은 chatgpt 에 대한 prompt 를 만들어주는 것이 이것이 하는 일이다. 요즘 이런식의 툴들이 많이 보인다.

위 code 에는 다음과 같은 prompt 를 이용한다.

const makeQAPrompt = (projectName: string, repositoryUrl: string, contentType: string, chatPrompt: string, targetAudience: string) =>
  PromptTemplate.fromTemplate(
    `You are an AI assistant for a software project called ${projectName}. You are trained on all the ${contentType} that makes up this project.
  The ${contentType} for the project is located at ${repositoryUrl}.
You are given the following extracted parts of a technical summary of files in a ${contentType} and a question. 
Provide a conversational answer with hyperlinks back to GitHub.
You should only use hyperlinks that are explicitly listed in the context. Do NOT make up a hyperlink that is not listed.
Include lots of ${contentType} examples and links to the ${contentType} examples, where appropriate.
Assume the reader is a ${targetAudience} but is not deeply familiar with ${projectName}.
Assume the reader does not know anything about how the project is strucuted or which folders/files are provided in the context.
Do not reference the context in your answer. Instead use the context to inform your answer.
If you don't know the answer, just say "Hmm, I'm not sure." Don't try to make up an answer.
If the question is not about the ${projectName}, politely inform them that you are tuned to only answer questions about the ${projectName}.
Your answer should be at least 100 words and no more than 300 words.
Do not include information that is not directly relevant to the question, even if the context includes it.
Always include a list of reference links to GitHub from the context. Links should ONLY come from the context.
${
  chatPrompt.length > 0
    ? `Here are some additional instructions for answering questions about ${contentType}:\n${chatPrompt}`
    : ''
}
Question: {question}
Context:
{context}
Answer in Markdown:`,
  );

Reference

  1. Installation and Setup — LlamaIndex documentation : llama-index 설치
  2. Starter Tutorial — LlamaIndex documentation : test code 를 만들자

[컴][머신러닝] 재밌는 ai 를 활용한 기능들

ai / 인공지능/ 아이디어 / machine learning

재밌는 ai 를 활용한 기능들

작성중…

[컴][머신러닝] Prompt enginerring

 

ai / 사용법 / 좀 더 잘 사용하는 방법 / chatgpt / how to / better usage / better use

Prompt enginerring

prompt 는 ’뭔가를 하도록 유도하다’는 뜻이다.

Prompting | Learn Prompting :

  • AI에서는 AI 에게 어떤 일(task) 를 하라고 지시하는 process 가 prompting 이다.
  • AI 에게 instruction 들의 집합(the prompt) 하면 AI 가 그 task 를 수행한다.
  • GPT3 에게 What is 100*100? 을 물어보면, 1000이라고 대답한다. What is 100*100? Make sure your answer has the correct number of 0s 라고 물어보면, 10000 이라고 대답한다.
  • Make sure your answer has the correct number of 0s 라는 부분이 들어가야만 정답을 이야기 해줄까? 우리의 task 에 대한 최적화된 정답을 산출하는 prompt들을 만들려면 어떻게 해야 할까? 이부분에 대한 답을 구하는 것이 prompt engineering 이라고 한다.

현재 prompt engineering 에 대한 나의 정리

예를 들어, 포토샵이 있다면, 어떻게 해야 포토샵을 더 잘 쓸 수 있을까? 를 알기 위해, 어떤 식으로 하면 좀 더 우리가 원하는 편집 결과물이 나오는지를 알아내려고 하는 것이 prompt engineering 이라고 보면 되지 않을까?

그런데 최적화된 결과물이 어떻게 나오는지 원리에 집중하기 보다는, 즉, 포토샵의 동작원리에 집중하기 보다는, 포토샵의 메뉴를 다양하게 조합해 봐서, 결과물이 제대로 나오면, 그 방법을 공유하는 방식인 듯 싶다.

[컴][머신러닝] ChatGPT

 

ChatGPT

ChatGPT 는 website 에서 제공하는 서비스라고 보면될듯 하다. SaaS

https://chat.openai.com/chat 는 OpenAPI 쪽에서 자신들의 GPT 를 대화하는 방식으로 사용될 수 있도록 ’ChatGPT라는 Model’을 만들었는데, 이것을 훈련시키려고 만든 사이트라고 보면 될 것 같다.

현재 연구용 prview (research preview) 상태이고, 그래서 무료라고 한다.

ChatGPT 능력들

from ref.2

김수현 한국과학기술연구원(KIST) 인공지능연구단 책임연구원은 “기존 GPT-3는 텍스트를 입력해서 뒤에 어떤 텍스트가 이어질 지 예상하는 방식으로 작동했는데, 아무래도 패턴만을 배우다보니 자연스러운 대화의 맥락을 만드는 건 어려움이 있었다”며 “GPT-3.5는 텍스트에 대한 사람의 판단을 함께 가르치다보니 훨씬 자연스러운 대화가 가능해졌다”고 설명했다.

ChatGPT의 한계[ref. 2]

  • 현재 공개된 ChatGPT는 2021년까지의 데이터를 기반으로 학습 --> 기본적으로 최신 정보를 가지고 있지 않다.
  • 실시간으로 정보를 찾는 것도 아니다. --> 현재 상황에 맞는 정보를 제공할 수도 없다.
  • 정보의 신뢰도의 한계
    • 주어진 데이터를 바탕으로 학습하는 AI의 특성상 잘못된 정보가 섞여 있으면 ChatGPT가 내놓는 답변 자체가 잘못될 가능성
    • 공신력 있는 정보를 가려내지 못한다.
  • Stack Overflow temporarily bans answers from OpenAI’s ChatGPT chatbot | ZDNET : StackOverflow 쪽에서는 ChatGPT를 이용해서 빠르게 여러질문에 답하는 것을 금지시켰다. 이 답들이 그럴싸 해보이지만, 틀린부분도 많은데, 이것이 검증없이 너무 많은 양의 답변들이 올라오게 되니 문제가 되는듯 하다.

References

  1. “구글의 시대 끝났다” 평가 나온 Chat GPT… AI 대화가 검색 대체할까 - 조선비즈, 2022-12-06

[컴] 정보이론에서 entropy

information theory

정보이론에서 entropy

자세한 이야기는 ref. 1, 2, 3 을 통해 배우자.

모든 사건이 같은 확률로 일어나는 것이 가장 불확실하다.즉, 랜덤하게 사건이 일어나는 것이 제일 확실하다. 예를 들어, 우리가 동전던지기를 한다고 했을 때도, 한번은 앞면, 다른 한번은 뒷면, 이렇게 계속 ’앞뒤앞뒤’로 나오는 것이 가장 불확실하다.

’엔트로피(entropy)’는 이 불확실한 정도를 이야기 한다. 즉,

  • 사건이 랜덤하게 일어나는 경우
    –> 각 사건이 발생하는 확률이 random하다.
    –> 제일 확실한 경우이다.
    –> 불확실성이 낮다.
    –> entropy 값이 가장 낮다.
  • 사건이 규칙적으로 일어나는 경우
    –> 각 사건이 발생하는 확률이 다 같다.
    –> 제일 불확실한 경우이다.
    –> 불확실성이 높다.
    –> entropy 값이 가장 높게 된다.

entropy 란, 최적의 전략하에서 그 사건을 예측하는 데에 필요한 질문 개수를 의미한다.
이 말은 곧 최적의 전략 하에서 필요한 질문개수에 대한 기댓값을 구하면 된다는 뜻이다.
entropy 가 감소한다는 것은 우리가 그 사건을 맞히기 위해 필요한 질문의 개수가 줄어든다는 이야기다.

위의 사건이 발생하는 경우와 연관지어서 이야기해보면,

  • 사건의 발생확률이 한쪽으로 몰려있다.
    --> 필요한 질문 개수의 평균은 줄어들게 된다.
    --> 적은 질문으로 어떤 사건이 일어날 지 맞출 수 있기 때문이다.
    --> 그 사건을 예측하는데 필요한 질문 개수가 작다

만약 아래와 같은 이산확률분포(discrete probability distribution)가 있다고 하자.

  • A 가 나오는 확률은 50% = 1/2
  • B 가 나오는 확률은 12.5% = 1/8
  • C 가 나오는 확률은 12.5% = 1/8
  • D 가 나오는 확률은 25% = 1/4

그러면, 처음에 나오는 문자가 뭔지를 알려면 몇번의 질문을 해야 할까? 이것에 대한 자세한 설명은 ref. 1 을 보면 된다.

결과적으로, 아래처럼 1개의 글자를 추려내기 위해서는 평균적으로 1.75개의 질문을 하면 된다는 결론이 난다.

\(p(A) \cdot 1 + p(B) \cdot 3 + p(C) \cdot 3 + p(D) \cdot 2 = 1.75\)

각 문자를 판단하기 위해 하는 질문횟수는 다음과 같다.

  • A는 1번 : \(\log_2(\frac{1}{1/2})\)
  • B는 3번 : \(\log_2(\frac{1}{1/8})\)
  • C는 3번 : \(\log_2(\frac{1}{1/8})\)
  • D는 2번 : \(\log_2(\frac{1}{1/4})\)

즉, 아래와 같은 식이 성립한다.

\((사건발생확률) \cdot log_{2}(\frac{1}{사건발생확률})\)

그리고, 이것을 모든 경우에 대한 값을 합산하면 아래와 같이 된다. 이것이 entropy 이다. 이 entropy 를 \(H\)라고 정의하자.

\(\begin{align} H & = \sum (사건\,발생확률) \cdot \log_2(\frac{1}{사건\,발생확률}) \\ & = \sum_i p_i \ \log_2(\frac{1}{p_i})\\ & = - \sum_i p_i \ \log_2(p_i) \end{align}\)

Reference

  1. 초보를 위한 정보이론 안내서 - Entropy란 무엇일까

[컴][머신러닝] Markov Chains 설명

Markov chain / 마르코브 / 마르코프 체인 /

Markov Chains 설명

각 사건의 확률이 이전 사건에서 얻은 상태에만 의존하는 일련의 가능한 사건들을 설명하는 확률적 모델(stochastic model)이다. 비공식적으로 이것은 “그 다음에 무슨 일이 일어날지는 오직 지금 상황에 달려 있다”고 생각할 수 있다.[ref. 4]

See Also

  1. 쿠…sal: [컴] 조건부 확률 설명, conditional probability : '마르코브 체인'은 현재사건의 확률이 이전 사건에서 나온 상태에서 시작한다. 그래서 '조건부확률' 과 같은 뜻이라고 볼 수 있다. $P(A_{2}|A_{1})$ 라고 하면 '$P(A_{1})$ 이 일어난 후, 그 사건을 100%로 놓은 상황에서 $P(A_{2})$ 가 일어날 확률'이 되기 때문이다.
  2. 조건부 확률부터 마르코프까지 - 4) 마르코프 체인: '마르코프체인'과 나이브베이'의 차이를 이야기 해준다. 참고로, 둘다 조건부확률이다.

Reference

  1. Markov Chains explained visually
  2. Examples of Markov chains - Wikipedia
  3. 마르코프 체인 (Markov Chain) 정의 및 예시
  4. Markov chain - Wikipedia

[컴][머신러닝] pytorch 로 따라해보는 diffusion model

ai 그림그리기 원리 / 어떻게 그림을 머신러닝으로 그리나 / how to / draw / machine learning / ML / 이미지 생성 모델

정리중…

pytorch 로 따라해보는 diffusion model

ref. 1 의 내용을 정리했다.

잡음제거 확산 확률 모델(Denoising Diffusion Probabilistic Models, DDPMs)은 확산모델(diffusion models), score-based generative models 또는 간단하게 autoencoders 라고 불린다.

이 방법은 2015년 쯤 소개되었지만,

까지 계속 이 방법을 독립적으로 발전시켜왔다.

diffusion model 들에는 여러 관점들이 있다. 여기서는 dicrete-time perspective(이산시간 관점) 를 채용했다. (잠재변수모형, latent variable model) 다른 관점들도 꼭 확인해 봐야 한다.

유명한 예:

package 설치

pytorch 설치가 돼 있어야 한다.

pip install -q -U einops datasets matplotlib tqdm

설명

set-up(설정)은 2가지 프로세스로 이뤄진다.

  1. 우리의 선택에 대한 고정된(즉, 미리정의된) forward diffusion process \(q\) 가 있고, 이것은 pure noise 가 될때가지 점차적으로 Gaussian noise 를 이미지에 더한다.
  2. 학습된 reverse denoising diffusion procee \(p_{\theta}\) 에서는 신경망(neural network) 이 훈련된다. 실제 이미지가 나올때까지, pure noise 에서 시작해서, 점차적으로 이미지의 noise 를 없애는 것을 훈련하게 된다.

t 에 의해 인덱싱된 forward, reverse process 들 모두, 한정된 tiem step 수 T 동안 일어난다.(DDPM 저자들은 T = 1000 을 사용했다.) 당신의 ’data 분포’에서 t=0 을 가지고 시작한다. t=0 는 실제 이미지 x0 를 샘플링하는 시점이다.

forward process 는 각 time step t 에서 Gaussian distribution 의 몇몇 noise 를 샘플링한다. 그리고 그것을 이전 time step 의 image 에 더한다. ‘충분히 큰 T’ 와 ’각 time step 에서 noise 를 더하기 위한 잘 행동된 schedule’이 주어지면,
점차적인 과정을 통해서, t=T 인 시점에 isotropic Gaussian 분포 라 불리는 것을 얻을 것이다.

좀더 수학적인 설명

궁극적으로 다루기 쉬운 손실 함수(loss function)이가 필요하다. 이 loss function 은 우리의 neural network 가 최적화 작업을 하는데 필요 하다.

\(q(x_{0})\) 를 실제 데이터 분포라고 하자. 이 \(q(x_{0})\) 는 ‘실제 이미지’(real image) 이다. 우리는 이 분포에서 샘플을 채취하여 \(x_{0}\sim q(x_{0})\) 라는 이미지를 얻을 수 있다.

우리는 전방 확산 프로세스(forward diffusion process) 를 \(q(x_{t}|x_{t-1})\) 로 정의한다.
이 프로세스는 각 time step t 에서 가우스 노이즈(Gaussian noise)를 추가한다.

알려진 분산 스케줄(variance schedule) ‘\(0 < \beta_{1} < \beta_{1} < ... < \beta_{T} < 1\)’ 에 따라 \(q(x_{t}|x_{t-1})\) 는 다음과 같이 적을 수 있다.

  • \(q(x_{t}|x_{t-1}) = N(x_{t}; \sqrt{1-\beta_{t}}x_{t-1}, \beta_{t}I)\)

가우시안 분포(Gaussian distribution)라고 부르는 정규분포(normal distribution) 는 2개의 parameter 로 정의되어 있다. ‘평균’(\(\mu\))과 ‘분산’(\(\sigma^{2}\)) 이다.

기본적으로, time step t 에서 각각의 새로운(미세하게 노이즈가 더 낀)이미지는

  • 평균값 \(\mu_{t}\)\(\sqrt{1-\beta_{t}}x_{t-1}\) 이고,
  • 분산 \(\sigma_{t}^{2}\)\(\beta_{t}\)

conditional Gaussian distribution (조건부 가우시안 분포)으로부터 그려진다.

이 분포는 우리가 \(\varepsilon \sim N(0, I)\) 에서 sample 을 가져오고, 그리고 나서 \(x_{t}\)\(\sqrt{1-\beta_{t} }x_{t-1} + \sqrt{\beta_{t}}\epsilon\) 로 설정하면 얻을 수 있다.

각 time step \(t\) 에서 \(\beta_{t}\) 는 상수(constant) 가 아니다.

사실, 1 은 소위 이야기하는 variance schedule(분산 스케줄) 을 정의한다. 이 variance schedule은 1차 함수, 2차 함수, 코사인 함수등이 될 수 있다.

\(x_{0}\) 에서 시작하자. 우리는 \(x_{1}, ..., x_{t}, ..., x_{T}\) 로 끝난다. 여기서 \(x_{T}\) 는 순수한 Gaussian noise 이다. (단, 우리가 schedule 을 적절하게 설정했어야 한다.)

이제, 만약 우리가 조건 분포(conditional distribution) “\(p(x_{t-1}|x_{t})\)” 을 안다면, 우리는 역으로 process 를 실행할 수 있다.
random Gaussian noise \(x_{T}\) 샘플을 가져오고, 그리고 나서 점차적으로 그 noise 들을 제거(denoise)하여 우리는 실제 분포 \(x_{0}\) 의 샘플을 얻게 된다.

그러나, 우리는 \(p(x_{t-1}|x_{t})\) 를 모른다. 이것은 다루기 힘들다. 왜냐하면 이 조건부 확률(conditional probability) 를 계산하기 위해 모든 가능한 이미지들의 분포를 알아야 하기 때문이다. 그렇기 때문에, 우리는 이 조건부 확률 분포(conditional probability distribution) 의 근사치를 계산하기 위해 신경망(neural network) 을 지렛대로 이용할 것이다.

이것을 \(p_{\theta}(x_{t-1}|x_{t})\) 라고 부르자. 이것은 신경망의 parameter 인 \(\theta\) 를 가지고 있고, gradient descent 에 의해 update 된다.

뒷방향으로의 process (backward process)의 조건부확률 분포(conditional probability distribution) 을 표현하기 위해서 우리는 신경망이 필요하다. 이 reverse process 또한 Gaussian (정규분포)이라고 가정하자.
모든 Gaussian 분포는 2개의 parameter 들로 정의된다는 것을 떠올리자.

  • 평균 : \(\mu_{\theta}\)
  • 분산 : \(\sigma_{\theta}\)

그래서 우리는 다음과 같이 이 process 를 매개변수로 표현할 수 있다.

  • \(p_{\theta}(x_{t-1}|x_{t}) = N(x_{t-1};\mu_{\theta}(x_{t}, t), \sum\nolimits_\theta (x_{t}, t))\)

평균, 분산 값은 또한 noise level \(t\)에 따라 달라진다.

그런이유로, 우리의 신경망은 ’평균’과 ’분산’을 학습(표현)하는 것이 필요하다.

그러나, DDPM 저자들은 ’분산’을 고정하기로 정했다. 그리고 신경망이 이 조건부확률 분포(conditional probability distribution)의 평균값 \(\mu_{\theta}\) 만을 학습하게 했다.

논문에서:

First, we set \(\sum\nolimits_\theta (x_{t}, t) = \sigma_{t}^{2}I\) to untrained time dependent constants. Experimentally, both \(\sigma_{t}^{2} = \beta_{t}\) and \(\sigma_{t}^{2} = \widetilde{\beta_{t}}\) (see paper) had similar results.

먼저, 우리는 \(\sum\nolimits_\theta (x_{t}, t) = \sigma_{t}^{2}I\) 를 설정했다. 훈련되지 않은, 시간에 종속적인 상수로 set했다. 실험에선, \(\sigma_{t}^{2} = \beta_{t}\)\(\sigma_{t}^{2} = \widetilde{\beta_{t}}\), 둘다 비슷한 결과를 얻었다.

이것은 그리고 나서 나중에 Improved diffusion models paper 에서 향상됐다. 이곳에서 신경망은 또한 이 backward process 의 분산, 평균을 배운다.

그래서 우리는 신경망이 단순히 이 조건부 확률 분포(conditional probability distribution)의 ’평균’만을 배우면 된다고 가정할 것이다.

간단정리:

backward process 에 대한 식(model)을 구하려면, 모든 가능한 이미지들의 분포를 알아야 하는데, 이것은 어렵다. 그래서 근사치에 대한 model을 구하려한다. 그것을 위해 neural network 를 사용했다.

objective function 정의하기

backward process 의 평균을 학습하기위한 objective function(목적함수)를 유도하기 위해 저자들은 \(q\)\(p_{\theta}\) 의 조합은 variational auto-encoder(VAE, 가변자동인코더) 처럼 보여질 수 있다.고 본다.(Kingma et al., 2013) 그런 이유로, variational lower bound(ELBO, 변동하한) 는 기초적인 실제 데이터 샘플 \(x_{0}\) 에 대한 음의 log 확률(negative log-likelihood)을 최소화하는데 사용되어질 수 있다.(ELBO 에 대한 자세한 사항에 대해서는 VAE 논문을 참조한다.)

이 process를 위한 ELBO 는 각 time step \(t\) 에서의 loss들의 합이다. 즉, \(L=L_{0} + L_{1} + ... + L_{T}\).

forward \(q\) process 와 backward process 의 구조에 의해 loss의 각 항(\(L_{0}\)는 제외) 은 실제적으로 2개의 정규분포 사이의 KL divergence 이다. 이 KL divergence는 평균에 대한 L2-loss로 명시적으로 기록된다.

구성된 forward procee \(q\)의 직접적인 결과는, Sohl-Dickstein et al.에 의해 보여진것처럼, 우리는 \(x_{0}\) 가 어떤 임의의 noise level 조건에 있더라도 \(x_{t}\) 를 샘플링할 수 있다. (왜냐하면, 가우시안(Gaussian)들의 합은 또한 가우시안이니까.) 이것은 매우 편리하다. 왜냐하면 \(x_{t}\)을 샘플링 하기 위해서 \(q\) 를 반복적으로 적용할 필요가 없기 때문이다.

  • \(q(x_{t}|x_{0}) = N(x_{t};\sqrt{\overline{\alpha}_{t}}x_{0},(1 - \overline{\alpha}_{t})I)\)
  • \(\alpha_{t} := 1 - \beta_{t}\)\(\overline{\alpha}_{t} := \prod\nolimits_{s=1}^{t}\alpha_{s}\)

이 방정식을 ‘nice property’ 라고 부르자. 이 뜻은 가우시안 noise 를 샘플로 취할 수 있고, 적절하게 확장(scale)할 수 있다. 그리고 \(x_{0}\)에 더해서 \(x_{T}\)를 직접얻을 수 있다.

\(\overline{\alpha}_{t}\) 는 알려진 \(\beta_{t}\) variance schedule 에 대한 함수들이다. 알려졌기에, 미리 계산가능하다.
그래서 이것들은 훈련중에, loss function \(L\) 의 random 항목들을 최적화할 수 있게 해준다.
(다른말로 하면, 훈련중에 랜덤하게 \(t\)를 샘플링하고, \(L_{t}\)를 최적화 해준다.)

Ho et al. 등에서 보여진바와 같이, 이 property 의 또 다른 장점은 신경망이 ‘loss들을 구성하는 KL 항목들’ 내의 noise level \(t\) 에서 ‘네트워크 \(\varepsilon_{\theta}(x_{t}, t)\) 를 통해서 추가된 noise’ 를 학습하도록 하기위해 평균을 다시 매개변수화 한다.(reparametrize) (이 훌륭한 블로그 게시물을 참조하자.)

이 말은 우리의 신경망이 평균 예측기(mean predictor) 보다는 “noise predictor”(노이즈 예측기)가 된다는 뜻이다.

개인적인 해석

부인(Disclaimer): 이 해석은 틀릴 수 있다.

이것을 대략적으로 이해한 바를 적으면, DDPM 은 이미지를 추상화시키고(noise 라고 보면 될듯), 이 추상화된 이미지에서 부터 다시 구체적인 이미지를 뽑아내는 것인 듯 하다.

즉, 특정이미지의 변형을 뽑아내는 방법인 듯 하다. 그래서 아예 새로운 그림을 그리는 것이 아닌, 있는 그림의 변형을 만들어내는 방법인듯 보인다.

entropy

  1. 초보를 위한 정보이론 안내서 - Entropy란 무엇일까
  2. What’s an intuitive way to think of cross entropy? - Quora
  3. Information entropy (video) | Khan Academy
  4. Kullback-Leibler Divergence Explained — Count Bayesie

See Also

  1. [논문 리뷰] Denoising Diffusion Probabilistic Model(2020)
  2. Diffusion model 설명 (Diffusion model이란? Diffusion model 증명) - 유니의 공부
  3. Generating images with DDPMs: A PyTorch Implementation | by Brian Pulfer | MLearning.ai | Medium
  4. machine learning - Objective function, cost function, loss function: are they the same thing? - Cross Validated
  5. What are Diffusion Models? | Lil’Log
  6. Introduction to Diffusion Models for Machine Learning

Reference

  1. The Annotated Diffusion Model