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

[컴] 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

[컴][머신러닝] PyTorch 설치

파이토치 / 텐서플로우 / tensor / flow / 설치 방법

PyTorch 설치

CUDA 설치

CUDA 설치 를 참고하자

version 확인:

D:\>nvcc --version
nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2022 NVIDIA Corporation
Built on Wed_Sep_21_10:41:10_Pacific_Daylight_Time_2022
Cuda compilation tools, release 11.8, V11.8.89
Build cuda_11.8.r11.8/compiler.31833905_0

PyTorch 설치

여기선 virtualenv 를 만들어서 설치했다.

D:\diffusion>virtualenv env

주의할 점은 자신의 cuda version 이 11.8 이라해도, pytorch 의 cuda 버전은 11.6을 택해야 한다. 11.8에 대한 경로가 없어서, cuda 가 없는 경우에 대한 pytorch 를 설치하게 된다.

설치

D:\diffusion>.\env\Scripts\activate.bat
(env) D:\diffusion>pip3 install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu116
Looking in indexes: https://pypi.org/simple, https://download.pytorch.org/whl/cu116
Collecting torch
  Downloading https://download.pytorch.org/whl/cu116/torch-1.12.1%2Bcu116-cp39-cp39-win_amd64.whl (2388.0 MB)
     ---------------------------------------- 2.4/2.4 GB 877.5 kB/s eta 0:00:00
Collecting torchvision
  Downloading https://download.pytorch.org/whl/cu116/torchvision-0.13.1%2Bcu116-cp39-cp39-win_amd64.whl (2.6 MB)
     ---------------------------------------- 2.6/2.6 MB 9.6 MB/s eta 0:00:00
Collecting torchaudio
  Downloading https://download.pytorch.org/whl/cu116/torchaudio-0.12.1%2Bcu116-cp39-cp39-win_amd64.whl (1.2 MB)
     ---------------------------------------- 1.2/1.2 MB 10.9 MB/s eta 0:00:00
Collecting typing-extensions
  Using cached typing_extensions-4.4.0-py3-none-any.whl (26 kB)
Collecting requests
  Using cached requests-2.28.1-py3-none-any.whl (62 kB)
Collecting pillow!=8.3.*,>=5.3.0
  Using cached Pillow-9.2.0-cp39-cp39-win_amd64.whl (3.3 MB)
Collecting numpy
  Using cached numpy-1.23.3-cp39-cp39-win_amd64.whl (14.7 MB)
Collecting charset-normalizer<3,>=2
  Using cached charset_normalizer-2.1.1-py3-none-any.whl (39 kB)
Collecting idna<4,>=2.5
  Using cached idna-3.4-py3-none-any.whl (61 kB)
Collecting certifi>=2017.4.17
  Using cached certifi-2022.9.24-py3-none-any.whl (161 kB)
Collecting urllib3<1.27,>=1.21.1
  Using cached urllib3-1.26.12-py2.py3-none-any.whl (140 kB)
Installing collected packages: urllib3, typing-extensions, pillow, numpy, idna, charset-normalizer, certifi, torch, requests, torchvision, torchaudio
Successfully installed certifi-2022.9.24 charset-normalizer-2.1.1 idna-3.4 numpy-1.23.3 pillow-9.2.0 requests-2.28.1 torch-1.12.1+cu116 torchaudio-0.12.1+cu116 torchvision-0.13.1+cu116 typing-extensions-4.4.0 urllib3-1.26.12

CUDA 를 사용안하는 PyTorch 가 설치된 경우

D:\diffusion>.\env\Scripts\activate.bat
(env) D:\diffusion>pip3 install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu118
Looking in indexes: https://pypi.org/simple, https://download.pytorch.org/whl/cu118
Collecting torch
  Downloading torch-1.12.1-cp39-cp39-win_amd64.whl (161.8 MB)
     ---------------------------------------- 161.8/161.8 MB 2.7 MB/s eta 0:00:00
Collecting torchvision
  Downloading torchvision-0.13.1-cp39-cp39-win_amd64.whl (1.1 MB)
     ---------------------------------------- 1.1/1.1 MB 13.5 MB/s eta 0:00:00
Collecting torchaudio
  Downloading torchaudio-0.12.1-cp39-cp39-win_amd64.whl (969 kB)
     ---------------------------------------- 969.6/969.6 kB 10.2 MB/s eta 0:00:00
Collecting typing-extensions
  Downloading typing_extensions-4.4.0-py3-none-any.whl (26 kB)
Collecting numpy
  Downloading numpy-1.23.3-cp39-cp39-win_amd64.whl (14.7 MB)
     ---------------------------------------- 14.7/14.7 MB 6.5 MB/s eta 0:00:00
Collecting pillow!=8.3.*,>=5.3.0
  Downloading Pillow-9.2.0-cp39-cp39-win_amd64.whl (3.3 MB)
     ---------------------------------------- 3.3/3.3 MB 11.6 MB/s eta 0:00:00
Collecting requests
  Downloading requests-2.28.1-py3-none-any.whl (62 kB)
     ---------------------------------------- 62.8/62.8 kB ? eta 0:00:00
Collecting urllib3<1.27,>=1.21.1
  Downloading urllib3-1.26.12-py2.py3-none-any.whl (140 kB)
     ---------------------------------------- 140.4/140.4 kB 8.1 MB/s eta 0:00:00
Collecting idna<4,>=2.5
  Downloading idna-3.4-py3-none-any.whl (61 kB)
     ---------------------------------------- 61.5/61.5 kB ? eta 0:00:00
Collecting certifi>=2017.4.17
  Downloading certifi-2022.9.24-py3-none-any.whl (161 kB)
     ---------------------------------------- 161.1/161.1 kB 9.4 MB/s eta 0:00:00
Collecting charset-normalizer<3,>=2
  Downloading charset_normalizer-2.1.1-py3-none-any.whl (39 kB)
Installing collected packages: urllib3, typing-extensions, pillow, numpy, idna, charset-normalizer, certifi, torch, requests, torchvision, torchaudio
Successfully installed certifi-2022.9.24 charset-normalizer-2.1.1 idna-3.4 numpy-1.23.3 pillow-9.2.0 requests-2.28.1 torch-1.12.1 torchaudio-0.12.1 torchvision-0.13.1 typing-extensions-4.4.0 urllib3-1.26.12

설치 확인

(env) D:\diffusion>python
Python 3.9.0 (tags/v3.9.0:9cf6752, Oct  5 2020, 15:34:40) [MSC v.1927 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import torch
>>> x = torch.rand(5,3)
>>> print(x)
tensor([[0.7964, 0.4330, 0.9297],
        [0.1587, 0.6058, 0.9949],
        [0.9037, 0.8595, 0.1423],
        [0.1058, 0.2947, 0.9277],
        [0.1316, 0.2070, 0.1998]])
>>> torch.cuda.is_available()
False
>>>

[컴] AI 가 그려주는 그림을 얻는 사이트

AI 가 그림 그려주는 사이트 / 공짜 이미지 / 이미지 사용 / image how to get free / AI 로 그림 그리는 사이트

AI 가 그려주는 그림을 얻는 사이트

로그인 없이 이용가능한 사이트:

로그인 필요한 사이트:

See Also

  1. https://www.autodraw.com/ : 그림을 대충 그리면, 그림에 대한 candidate 가 뜬다.

References

  1. 10 Best AI Art Generators (2022) - Unite.AI

[컴][머신러닝] GPT-3

이 글은 ref. 1 에 대한 일부 번역이다.

GPT-3

  • GPT-3는 일반적인 언어 기반 작업(tasks)을 해결할 수 있다. 전례없이 쉽게 글을 만들고, 분류하고 다른 글 스타일과 글 목적들 사이를 자유롭게 움직인다.
  • GPT-3 은 generic(포괄적인, 일반적으로 사용가능한) 언어 모델이다.

NLP(Natural Language Processing)

NLP 는 글(text)과 말하는 단어들을 사람과 같은 방식으로 이해하는 컴퓨터를 만드는 것과 관련한 AI 분야중 하나.

현재 NLP는 다음 것들을 가지고 있다.

  • 통계학적으로 계산을 요구하는 언어학 모델(사람 language modling 의 rule-based modeling)
  • 머신러닝 모델
  • 딥러닝 모델

NLP 는 ‘스팸처리’, 기계번역, 가상 도우미와 챗봇들, 소셜미디어 감정경향분석, 글자 요약 등에 사용

language model 은 자연어 처리(NLP) application 들에서 가장 중요한 구성요소이다. 통계학적인 예측 기계들로 생각하면 된다. 이 기계는 text 를 input 으로 주면, output 으로 예측되는 것을 준다. 폰에서 ‘자동완성’ 기능을 생각하면 된다.

GPT-3 이전에는 잘동작하는 generic language model 이 없었다. 언어 모델은 이미 존재하는 알고리즘 및 아키텍처를 사용해서 텍스트 생성, 요약 또는 분류와 같은 하나의 특정 NLP 작업를 수행하도록 설계되었다.

GPT-3

Generative model 들, 자체생산이 가능한 모델
이건 통계적 모델링의 한가지 이다.
수학적으로 세상을 어림짐작하는 방법
2개의 통계모델이 있다.
generative 와 discriminative

generative 모델들은 새로운 data 를 만들 수 있다.
Discriminative 모델들은 다른 종류의 data 를 식별할 수 있다.

generative model 을 훈련하려면, dataset 을 모으고,
이 dataset 은 모델이 특정 task 를 수행하는 법을 배우게 하는데 도움을 주는 예제들의 모음이다.
보통 특정 분야에 대한 많은 양의 data 이다. 예를 들면, ’차’가 무엇인지 알게 하기위해 차에 대한 몇백만개의 차 이미지들

Pre-trained model 들

잘 동작하는 model 을 만들려면, 그것을 ‘특정변수’들의 집합을 이용해서 훈련해야 한다. 이 특정변수가 parameter 이다.
model 내부에 있는 설정변수이다. 이 값들은 training data 로부터 측정된다.
모델의 이상적인 parameter 들을 결정하는 과정을 ’trainning’ 이라고 한다.
모델은 성공적인 trainning iteration 을 통해서 parameter 값들을 배운다.

pre-trained model 은 특정 문제를 풀기위해 만들어진 model 이다.
아무것도 없이 처음부터 model 을 만드는 대신에, 다른 문제에서 훈련된 model 을 이용할 수 있다.
pre-trained model 을 가져와서 좀더 구체적인 trainning 을 시켜줄 수 있다.

ML(machine learning) 에서 model 은 dataset 위에서 훈련된다. 해결하려는 task 에 따라 data sample 의 크기나 종류가 다양하다. GPT-3 는 5개의 dataset 들의 text corpus 를 이용해서 훈련됐다.

  • Common Crawl: petabyte 의 data, OpenAPI 에서 curated, filtered version 을 사용
  • WebText2 : WebText 의 확장버전, 내부의 OpenAI corpus 이다. 품질좋은 웹페이지 크롤링 해서 모은 자료다. 좋은 품질을 위해서 적어도 3개이상 karma 가 걸린 Reddit 에 걸린 outbound link 들을 scrap 했다. 450만 링크에서 800만이 넘는 문서에서 가져온 40GB 의 text 가 있다.
  • Book1, Book2 : 다양한 주제에 대한 많은 책에서 가져온 text 들
  • Wkikipedia : Wikipedia 에 있는 모든 영어 기사들, 대략 600만개 이상의 기사들

GPT-3 는 확장적인 다양한 text corpus에서 미리훈련됐다(pre-trained). GPT-3 는 놀랍도록 많은 NLP task 들을 성공적으로 수행한다. user가 추가적인 example data 를 제공하지 않아도 말이다.

Transformer model 들

2가지 종류의 신경 망

  • sequence-to-sequence model
  • transformer model

transformer model 의 아이디어는 [1706.03762] Attention Is All You Need 에서 나왔다.

sequence-to-sequence(Seq2Seq) 구조는 transformer model 의 근간(backbone) 이다.
Seq2Seq 는 문장의 단어(word) 같은 요소들의 순서를 바꿔서 다른 sequence 로 바꿔준다.
이 seq2seq 는 ‘text 요약’과 ’image captioning’ 에서 큰 성공을 거둔상황이다.

Seq2Seq 는 특히 번역에서 특히 좋다.
번역에서는 특정 언어에서의 단어의 순서를 다른 언어의 다른 단어들 순서로 변환해준다.
Google translate 은 2016년 후반부터 비슷한 종류의 model 을 이용하기 시작했다.

Seq2Seq 는 2개의 model 로 이뤄져 있다. Encoder와 Decoder
Ecoder 와 Decoder 는 각각 2개의 언어를 번역할 수 있다. 2개가 갖는 공통적인 언어가 있어서 Encoder 가 B라는 언어를 읽어서 A라는 언어로 번역하면, 그것을 Decoder 가 읽고 그것을 C라는 언어로 번역한다.

transformers 와 attention mechanisms

Transformer architecture 또한 하나의 sequence를 다른 sequence 로 변환한다.
마찬가지로, Encoder와 Decoder의 도움을 받지만 기존의 seq2seq와 차이점이 있다.
Transformer architecture 는 2017년에 발명됐는데, 기계 번역 task 들에 대한 Ai들의 성능을 향상시키기 위해 발명됐다.

attention mechanism은 ‘인지적 주의집중’(cognitive attention) 을 흉내낸 기술이다.
예를 들면, 사람이 글을 읽을때, 현재 단어를 읽겠지만, 문맥을 제공하기 위해서 이전의 읽은 문장의 증요한 키워드를 기억하고 있다.

attention mechanism 도 비슷하다.
Encoder가 문장의 의미에 중요한 키워드를 적어서, 번역과 함께 Decoder에 제공한다
이런 키워드들이 Decoder가 번역을 더 쉽게 하게 해준다.
문장의 어떤 부분이 중요한지, 어떤 용어가 문맥을 제공하는지를 알 수 있게 됐기 때문이다.

attention mechanism 은 transformer 가 잡음을 걸러내고, 관련성에 더 집중하게 도와준다.
즉, 서로 어떤 관계가 있는지 표시되어 있지 않은 2개의 연관있는 단어들을 연결한다.

Transformer model 들은 더 거대한 구조와 더 거대한 양의 data 로 부터 이익을 얻는다.
큰 dataset 들을 이용한 훈련과 특정 task 들에 대한 fine-tuning(미세조정)은 결과를 향상시킨다.

GPT-3 는 Open API 형태로 제공된다.

GPT-2 는 15억개 parameter 들과 40GB 의 text 에서 훈련됐다.
GPT-3 는 1750억개의 parameter 들과 570 GB 의 text 에서 훈련됐다.
GPT-2 가 몇몇 후속 task 들에서 사용할 수 없었지만, GPT-3 는 심지어 예제 context 만 있는 좀더 이전에 보지못한 새로운 task(novel task) 들에서도 수행가능하다.

See Also

  1. GPT-3 🤖 (@gpt_three) / Twitter
  2. https://github.com/abhagsain/ai-cli : gpt 3를 이용해서 cli명령어에 대한 help를 가져오는 예제

Referenence

  1. GPT-3 Building Innovative NLP Products Using Large Language Models