정보엔지니어 (맥스웰의 도깨비, 양자컴퓨터)

AI로 무엇을 하다보면 linux에 GPU로 환경을 구성하는데, 도대체 잘 이해가 가지 않는 것이 이 버전 관계다.

Ubuntu 버전, GPU 버전, NVidia driver버전, cuda 버전, cudnn 버전... 등등 헷갈린다. 이제 그 관계를 이해해보자.

결론은 지금 '24년초 시점에서는 Ubuntu 22.10, NVidia driver는 GPU버전에 맞는것(홈페이지 참조), CUDA는 11.8을 중심으로 설치하자. cudnn은 8.7 정도를 선택하면 되고 쉽게 바꿀 수 있다. 각각의 버전을 바꾸고 싶은데 다시 깔아야 할지 고민인가? 아래를 따라가보자.

0. 요약해보면 아래와 같다

  A. NVidia driver는 여러개를 설치할 수 없고 내 GPU, 원하는 CUDA버전에 맞는 가장 최근의 driver를 설치한다

  B. CUDA는 여러개의 버전을 설치해서 LD_LIBARY_PATH만 잘 바꾸면 그때그때 바꾸어 쓸 수 있다

  C. cudnn은 CUDA안에 library만 교체하면 되므로 역시 필요할때마다 특정 CUDA버전의 버전을 덮어쓸 수 있다.

       만약에 cudnn도 같은 CUDA에 여러가지 버전을 쓰려면 똑같은 CUDA를 여러개 복사해서 설치 한후, 그 각각에 cudnn을 설치하고 LD_LIBARY_PATH를 변경해서 쓰는 신공도 가능하다. cuda-11.8.A, cuda-11.8.B 식으로 설치하는 식이겠다

 다만 버전 결정 순서는, 내가 쓸 프레임웍이 지원한는 CUDA 버전은? 그에 맞는 내 GPU에 호환되는 NVidia driver 버전은? 그에 맞는 cudnn버전은? 그리고 python 버전은? 식으로 결정되어 간다. cuda, cudnn, python은 여러개의 버전을 설치해놓고 번갈아가면서 쓸 수 있다.

1. 먼저 필요한 CUDA 버전이 중요하다. CUDA 11.8이 가장 많이 호환되는 CUDA 버전이다.

 판단기준 : 내가 쓰는 프레임웍(pytorch, tensorflow?)이 지원하는 CUDA는 무엇인가? 대개 11.8이다

 CUDA는 최근에 11, 12시리즈가 시장에서 주력으로 사용되는데, 많은 오픈소스 ML 프레임웍이 11버전을 지원한다.

 특히 우리의 가장 중요한 친구 pytorch 2.1 미만 버전들이 CUDA 11에 의존한다. tensorflow나 주력으로 쓰는 framework들이 지원하는 버전을 확인해서 만약에 CUDA 12를 지원한다면 12버전을 쓸 수도 있겠다. 하지만 아직은 최신 프레임웍의 버전들만 간신히 지원하는 CUDA12를 쓸 용기는 없다. 우리는 가져다 쓰는 기존 소스코드들은 예전 버전인 경우가 더 많기 때문이다. 물론 CUDA12에 최신 버전 프레임웍을 설치해서 새로 소스코드를 짤 수도 있겠지만 그런 경우는 흔하지 않겠다.

 그러니 CUDA 11.8을 설치하자. 참고로 아래는 tensorflow의 버전별 CUDA + cudnn 버전이다. 각 프레임웍들이 각각 이런 정보를 공개한다.

https://www.tensorflow.org/install/source?hl=ko#gpu

 그리고 CUDA를 여러가지 버전으로 설치할 수 있을까? 정답은 Yes이다. 원하는 CUDA버전을 설치하면

 /usr/local/cuda-x-x/ 식으로 설치되고 이 디렉토리가 /usr/local/cuda로 심볼릭 링크가 걸린다(어떤 패키지들은 이 /usr/local/cuda를 참조하기 때문이다)

여러개의 cuda버전을 어떻게 참조할까? 바로 LD_LIBRARY_PATH라는 lib파일 참조 경로를 바꾸면 된다. 이 설정을 각 계정의 .bashrc에 반영하면 기 계정으로 로그인하면 해당 환경을 자동으로 사용하게 된다. 계정마다 별도의 설정으로 진행하자.

$ export PATH=/usr/local/cuda-x-x/bin:${PATH}

$ export LD_LIBRARY_PATH=/usr/local/cuda-x-x/lib64:${PATH}

 심볼릭 링크를 바꾸어 주어야 하는 상황이면 아래처럼 한다

$ cd /usr/local/

$ ls -al cuda          #해당 명령으로 지금은 어느 버전으로 연결되었는지 확인하자

 cuda -> cuda-y-y

$ rm cuda

$ ln -s /usr/local/cuda-x-x cuda

CUDA를 설치할때는 linux의 경우 아래와 같이 run local을 다운로드 받은 후 아래 driver를 먼저 설치한 후, 실제 CUDA설치시에는 해당 driver를 skip하고 설치하여 혼란을 방지한다.

아래 드라이버와 CUDA설치가 같이 이루어지게 되는데, 잘 맞지 않는다면 언제나 아래 명령으로 처음부터 다시 설치할 수 있다.

$ sudo apt install -y ubuntu-drivers-common   #맨처음이라면

$ sudo apt-get purge nvidia*

$ sudo apt-get autoremove

$ sudo apt-get autoclean

$ sudo rm -rf /usr/local/cuda*

$ sudo apt install build-essential      #gcc가 없는 경우

$ sudo ubuntu-drivers devices     #추천 nvidia drivers를 찾을 수 있다(recommended)

$ sudo apt install nvidia-driver-535  #추천받은버전

$ reboot

이후 cuda를 다시 설치하되, nvidia driver만 skip하고 설치한다.

(ex> $ sudo sh cuda_11.8.0_520.61.05_linux.run  / nvidia driver는 uncheck하고 진행)

2. NVidia driver는 아래와 같은 CUDA와의 호환 관계를 갖는다. 최신 CUDA는 최신 NVidia driver가 필요하다.

 판단기준 : 내가 쓰는 CUDA 버전이 최신일수록, 최신의 NVidia driver를 가져다 설치해야 하는데, 내가 가진 GPU카드별로 지원하는 Driver 버전이 다르다. 오래되거나 어떤 GPU는 Driver 버전 지원도 나쁘다. 거꾸로 내가 써야할 CUDA 버전을 지원하는 NVidia driver를 지원하는 GPU를 사야할 수도 있다. 

 즉 어느정도 Driver 버전 이상이 되어야, 최근의 CUDA 버전이 지원된다. Linux와 Windows가 조금 다른 것에 주의하자.

아래가 대략의 정보이고 세부 정보는 이 링크를 확인해보자. https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html#id6

 그리고 언급했듯이, 유의할 것은 해당 Driver 버전 중 일부는 특정 GPU 카드를 지원하지 않을 수 있다. 따라서 내가 가진 GPU 카드가 지원되는 드라이버 버전을 선택하자. 각 지원 버전은 NVidia 사이트에서 역시 확인이 가능하다. 신기하게도 GPU마다 지원되는 버전이 들쑥날쑥하니 꼭 내 GPU카드가 지원하는 버전을 확인해두어야 한다.

 혹시 내가 설치해서 쓸 OS Linux Package들이 이 드라이버 버전을 띄엄띄엄 지원할 수도 있으니, 아예 Linux에서 배포판 별로(ubuntu?) 지원되는 버전별로 찾아봐서 내 GPU를 지원하는지 확인할 수도 있다.

https://www.nvidia.co.kr/Download/index.aspx?lang=kr

대략 NVidia driver 525나 520, 515버전 등을 많이 설치하긴 한다. 여기서는 CUDA 11.8을 추천하려고 하므로 520이상 버전을 설치하려고 노력해보자.

참고로 아래 명령을 통해 linux에 설치된 GPU정보나, 추천 드라이버를 제공받을 수 있다

$ lshw -C display           #RTX4080예시이다

  *-display                 
       description: VGA compatible controller
       product: NVIDIA Corporation
       vendor: NVIDIA Corporation
       physical id: 0
       bus info: pci@0000:01:00.0
       version: a1
       width: 64 bits
       clock: 33MHz

$ sudo ubuntu-drivers devices          #RTX4080예시이다

== /sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0 ==
modalias : pci:v000010DEd00002704sv00001462sd00005111bc03sc00i00
vendor   : NVIDIA Corporation
driver   : nvidia-driver-545-open - third-party non-free
driver   : nvidia-driver-535 - third-party non-free
driver   : nvidia-driver-535-server - distro non-free
driver   : nvidia-driver-525-server - distro non-free
driver   : nvidia-driver-550-open - third-party non-free
driver   : nvidia-driver-550 - third-party non-free recommended
driver   : nvidia-driver-525 - third-party non-free
driver   : nvidia-driver-535-server-open - distro non-free
driver   : nvidia-driver-525-open - distro non-free
driver   : nvidia-driver-545 - third-party non-free
driver   : nvidia-driver-535-open - distro non-free

 불행히도 nvidia driver는 multi로 쓸 수는 없고, 다시 설치하고 reboot해야한다. (다만 recommended가 너무 낮지 않으면 그것을 선택하면 좋다)

3. Ubuntu 버전과는 어떻게 되는가? 23.10보다는 22.04가 더 유리하다.

 판단기준 : Ubuntu 배포판 버전이 아니라, 설치된 gcc 버전이 중요하다. CUDA 11을 컴파일하기 위해 구 버전인 gcc 10이 필요하기 때문이다.

 Ubuntu 23.10은 GCC 13버전 컴파일러를 디폴트로 사용하는 반면, CUDA 11/cudnn 등 컴파일에 GCC 10가 필요다. 그래서 사실은 Ubuntu 23.10을 사용해도 GCC 10버전 컴파일러를 디폴트로 정하면 CUDA 11을 쓸 수 있다! 그런데 이 Ubuntu에서 GCC 버전을 왔다갔다 설정하면서 설치할 배짱이 없다면 그냥 Ubuntu 22.04을 설치하자. 

혹시 Ubuntu 23.10을 써야한다면 아래 가이드를 참고하자. gcc 버전을 바꾸어 설치하는 방법과 다시 gcc 버전을 원복하는 방법이 나와있다.

https://www.yodiw.com/install-cuda-11-on-ubuntu-23-10/

그래서 이러한 번거로움 때문에 Ubuntu 22.04을 설치해서 운영하도록 추천하게 된다.

4. cudnn은 어떻게 할까?

 판단기준 : CUDA 처럼 사용하는 프레임웍별로 필요한 버전을 설치해줘야한다. 대략 8.7 버전 정도가 현재는 제일 무난하다.

 cudnn의 8.7.0버전은 CUDA 11과 12모두 각각에 개별 버전별로 따로 있다(즉 cudnn 8.7 버전이 CUDA 11, 12에 각각 별개의 배포판이 있다). 다행히 이 cudnn은 설치 후에도 쉽게 교체 및 추가 할 수 있다. 여러개를 설치하고 전환도 가능하다. 그저 배포하는 압축파일을 풀어서 폴더 그대로 기존의 설치된 cuda폴더의 include/lib 파일만 교체해주면 그만이기 때문이다.

예를 들면 CUDA가 /usr/local/cuda-11.8로 설치되어 있고 /usr/local/cuda -> /usr/local/cuda-11.8로 링크가 걸려있다고 치자. 그러면 cudnn은 해당 버전 압축 파일을 받아, 파일의 압축을 적절한 곳에 푼 다음에 아래처럼 복사해 덮어 씌우면 된다.

물론 버전이 바뀔때마다 같은 작업을 하면 된다. 그러니까 여러 버전의 압축을 풀고, 쓸때마다 버전을 바꾸어 복사한 후 필요한 프로그램을 실행하면 된다.

아래를 통해 cudnn 배포판 다운로드 (로그인이 필요하다) 하고 그 이하의 절차로 include/lib파일을 복사해버리자.

https://developer.nvidia.com/rdp/cudnn-archive

$ tar -xvf ${CUDNN_TAR_FILE}
$ sudo cp -P cuda/include/cudnn*.h /usr/local/cuda-11.8/include/
$ sudo cp -P cuda/lib/libcudnn* /usr/local/cuda-11.8/lib64/
$ sudo chmod a+r /usr/local/cuda-11.8/include/cudnn*.h /usr/local/cuda-11.8/lib64/libcudnn*

간단하게 버전을 어떻게 잡으면 될지 잡아보았다. 상기 모두 정상 설치되면 아래 명령을 통해 설치 정보를 알 수 있다.

$ nvcc --version
nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2022 NVIDIA Corporation
Built on Wed_Sep_21_10:33:58_PDT_2022
Cuda compilation tools, release 11.8, V11.8.89
Build cuda_11.8.r11.8/compiler.31833905_0

$ nvidia-smi

Sat Apr 27 16:54:09 2024       
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 525.125.06   Driver Version: 525.125.06   CUDA Version: 12.0     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|                               |                      |               MIG M. |
|===============================+======================+======================|
|   0  NVIDIA GeForce ...  On   | 00000000:01:00.0  On |                  N/A |
|  0%   39C    P8    25W / 320W |    592MiB / 16376MiB |      0%      Default |

흥미로운 것은 위 nvidia-smi의 CUDA은 추천 cuda 버전이다.

실제 설치 cuda 버전은 nvcc 명령으로 확인하자.

5. python 버전은 어떻게 할까?

 이것이야말로 실행할 프로젝트에 따라 다른데 대략 3.9~3.11정도가 추천되고 있다. 각 프로젝트별로 매우 세분화된 python버전을 요구할 수 있다(3.10.8이상 등). 따라서 설치할 프로젝트를 유심히 보는 수 밖에 없다. 하지만 우리는 여러개의 프로젝트를 실행하게 되기 때문에, 이 문제를 해결하기 위해 Anaconda(conda)를 사용하게 된다. 각 환경 별로 서로 다른 python과 package를 설정해 다중으로 사용하게 할 수 있는 합리적인 방법이다. Anaconda설치는 간단히 웹서핑해서 최근의 버전을 설치하면 된다. 서로 다른 버전으로 서로 다른 패키지 환경을 구성해 실행하는 것이 Anaconda의 마법같은 장점이다.

 Anaconda를 설치한 후 아래와 같은 형태로 이 python 버전에서 자유로워지자. 꼭 미리 conda create 명령으로 전용 환경을 구성한 후 conda activate를 통해 해당 환경을 활성화하고 실행하는 것이다. 디스크 용량을 필요로 하긴 하지만, 이보다 더 편안한 방법도 드물다. 적극 활용하도록 하자. (설치 경험이 없으신 분은 https://jongsky.tistory.com/21 를 참조하자) 아래는 대표적인 환경 구성 및 활성화, 설치 명령이다.

$ conda create -n llama2 python=3.9 -y

$ conda activate llama2

(llama2) $ pip install ...

$ ..

$ exit

이제 이 글을 몇번 앞뒤로 왔다갔다 하면서 설치해서 사용해보면, 여러분은 이제 어떤 버전이든 대응할 수 있게된다.

ollama는 많은 오픈소스 모델을 쉽게 구동해주는 프로젝트이다.

$ curl https://ollama.ai/install.sh 

$ chmod 755 install.sh

>> Downloading ollama...
######################################################################################################################################################################## 100.0%######################################################################################################################################################################## 100.0%######################################################################################################################################################################## 100.0%
>>> Installing ollama to /usr/local/bin...
[sudo] userid 암호: 
>>> Adding ollama user to render group...
>>> Adding current user to ollama group...
>>> Creating ollama systemd service...
>>> Enabling and starting ollama service...
>>> NVIDIA GPU installed.

$ ollama serve  #설치 후 자동 실행되지만 나중에는 이렇게 실행하면 된다.
Error: listen tcp 127.0.0.1:11434: bind: address already in use
$ ollama run llama3
pulling manifest 
pulling 00e1317cbf74... 100% ▕███████████████████████████████████████████████████████████████████████████████████████████████████████████████▏ 4.7 GB                         
pulling 4fa551d4f938... 100% ▕███████████████████████████████████████████████████████████████████████████████████████████████████████████████▏  12 KB                         
pulling 8ab4849b038c... 100% ▕███████████████████████████████████████████████████████████████████████████████████████████████████████████████▏  254 B                         
pulling c0aac7c7f00d... 100% ▕███████████████████████████████████████████████████████████████████████████████████████████████████████████████▏  128 B                         
pulling db46ef36ef0b... 100% ▕███████████████████████████████████████████████████████████████████████████████████████████████████████████████▏  483 B                         
verifying sha256 digest 
writing manifest 
removing any unused layers 
success 
>>> IT팀에 첫 부임하는 팀장인데 한글로 멋진 연설문을 써줘
Here's a potential team leader speech for your IT team in Korean:

---

**환영, 팀!**

저는 이날 처음으로 IT팀의 팀장이 되어 честь을 받은 것입니다. 함께 일하게 될 각자에게 고마워하는 기회를 가질 수 있습니다. 저는 이렇게 팀을 이끌어갈 수 있는 영광을 느끼고 있습니다.

** 우리의 사명 :*
우리 팀의 목표는 단순합니다. 이를 달성하기 위해 저는 각자의 강점과 재능을 활용하여 최고의 성과를 내겠습니다. 우리는 개별적으로는 아니라, 함께 일하는 조직체입니다. 기업의 성공을 위한 혁신적인 솔루션을 제공하며, 협동, 창의, 지속적 학습의 문화를 형성하겠습니다.

** 우리의 강점 :*
각자가 가진 Unique Skill, Perspective, Expertise 등을 활용하여 더 큰 것을 만들 수 있습니다. 우리는 소프트웨어 개발부터 지원까지 다양한 업무에 종사할 것입니다. 저는 각자의 재능을 믿고 있습니다.

** 앞으로의 도전 :*
저는 도전이 있을 줄 알아요. 하지만 저는 각자에게 믿음을 갖고 있습니다. 우리는 함께 도전을 맞아내고, collective Wisdom, Creativity, Determination 등을 사용하여 어떤도전이라도 이겨낼 것입니다. 우리는 실수를 통해 성장하고, 더 강한 팀이 될 것입니다.

** 이를 기대할 수 있는 것은 :*
저는 팀 리더로서 다음과 같은 약속을 합니다.
1. **오픈 커뮤니케이션** : 각자의 아이디어, 우려, 제안 등을 들으겠습니다. 각자의 목소리가 들립니다.
2. **클리어 골스** : 우리는 실제적 목표를 설정하여, 누구나 무엇을 위해 일하는지 알 수 있습니다.
3. **서포트 & 리소스** : 저는 각자가 필요한 도구, 교육, 지원 등을 제공할 것입니다.
4. **리코gnition & 레워즈** : 우리는 우리의 성공을 축하하고, 개인적인 공헌을 인정하여 서로를 이끌어갈 것입니다.

** 미래 :*
저는 이제 새로운 챕터에 들어가게 될 것 같습니다. 저는 이 팀이 어떤 것을 성취할지 궁금해합니다. 함께 이룰 수 있는 것은 무엇인지 찾아보겠습니다!

---
I hope this speech is inspiring and motivating for your IT team! Remember to tailor it to your team's specific needs and goals. Good luck with your new role as team 
leader! 🚀
---------------------------------------------------------------------------------------------------------
아래 링크에 ollama로 구동할 수 있는 모델이 나온다. llama3는 8B 4bit quantized 모델로 4.7GB정도 용량이다.

참고로  $ ollama run llama:70b 형태로 70B모델도 구동도 가능하다. 아래 각 모델의 세부 정보를 통해 어떤 형태까지 구동할 수 있는지 태그명을 알 수 있다.

https://ollama.com/library/

추천하고 싶은 한글이 어느정도 되는 모델들은 아래와 같다

$ ollama run gemma:instruct (한글이 그래도 나온다!)

$ ollama run llama3:instruct (한글로 설명해달라고 하면 제법 한다)

$ ollama run command-r (cohere의 모델인데 20b이지만 한글이 꽤 된다)

$ ollama run codegemma:instruct

 그리고 마지막으로 허깅페이스에 올라와있는 gguf 모델은 ollama create명령으로 설정하여 역시 사용할 수 있다. 해당 모델을 받고, 주소 등이 담긴 modelfile을 작성해서 custom 모델 사용이 가능한 것이다. 

https://huggingface.co/teddylee777/Llama-3-Open-Ko-8B-Instruct-preview-gguf/tree/main

에서 모델 파일을 다운로드 받고 ( Llama-3-Open-Ko-8B-Instruct-preview-Q6_K.gguf 를 예시로 보자)

$ ollama list
NAME            ID              SIZE    MODIFIED
gemma:instruct  a72c7f4d0a15    5.0 GB  3 hours ago
gemma:latest    a72c7f4d0a15    5.0 GB  About a minute ago

$ cat > modelfile
FROM ./Llama-3-Open-Ko-8B-Instruct-preview-Q6_K.gguf

TEMPLATE """[INST] {{ .System }} {{ .Prompt }} [/INST]"""

PARAMETER stop "[INST]"
PARAMETER stop "[/INST]"

SYSTEM "You are my AI assistant. you should answer in Korean"

$ ls

modelfile

Llama-3-Open-Ko-8B-Instruct-preview-Q6_K.gguf

$ ollama create llama-3-open-ko-8b-q6 -f modelfile
transferring model data
creating model layer
creating template layer
creating system layer
creating parameters layer
creating config layer
using already created layer sha256:62c16633326decbe7273021ad9178315347282763373fac0654773e35deeeb41
writing layer sha256:e6836092461ffbb2b06d001fce20697f62bfd759c284ee82b581ef53c55de36e
writing layer sha256:9aa5bc598c7961cbdfa0ec4dc7f94384f8dd2d6a314997b7900dc95ebf30c790
writing layer sha256:ed11eda7790d05b49395598a42b155812b17e263214292f7b87d15e14003d337
writing layer sha256:c0e945a015bccb863dcba3fb16fc7f9aed7fb244a4ea7401c91d72561881e759
writing manifest
success

$ ollama list
NAME                            ID              SIZE    MODIFIED
gemma:instruct                  a72c7f4d0a15    5.0 GB  3 hours ago
gemma:latest                    a72c7f4d0a15    5.0 GB  6 minutes ago
llama-3-open-ko-8b-q6:latest    e3420f154241    6.6 GB  50 seconds ago

$ ollama run  llama-3-open-ko-8b-q6

>>> 서울의 관광지를 소개해줘

 서울은 한국의 수도라 문화적, 역사적으로 중요한 도시예요. 추천해 주세요. 그리고 가 봐야 할 곳이 있어요. 1. 경복궁: 조선  왕조의 주요 궁궐, 꼭 봐야 하는 방문지 2. 남산 타워: 서울을 상징하는
이 타워는 숨막히는 전망을 제공해요 3. 북촌 한옥 마을: 한국 전통 건축을 보여주는 마을 4. 명동 쇼핑 지구: 현대 한국의 패션, 쇼핑을 경험하세요 5. N서울타워: 관람 데크에서 도시의 파노라마
뷰를 즐기세요. 가장 먼저 방문하고 싶은 곳은요?

이 문서는 ubuntu 22.04 + NVidia RTX 4080 H/W 하에서 진행하였다.

Stable Diffusion을 웹인터페이스 학습시킬 수 있는 kohya_ss 프로젝트가 존재한다. 여러가지 보조 기구를 제공해주고, 이미지가 있으면 자동으로 설정을 하고 학습까지 시켜준다. 단 아래는 전체 학습은 아니고 LoRA 즉 소규모의 부분 튜닝만 해주는 방법이다.

(그정도만으로도 꽤 성능이 향상된다고 알려져있다.)

https://github.com/bmaltais/kohya_ss

0. 아래를 먼저 진행한다

우선 다음을 준비할 필요가 있으며, CUDA와 cudnn은 아래 링크를 참조하여 설치한다. https://infoengineer.tistory.com/96

  1. CUDA 11.8

  2. python 3.10.9이상~3.11미만

  3. cudnn 8.7.0

따라서 용량이 충분한 디렉토리에서 아래와 같이 입력한다.

$ conda create -n kohya_ss python=3.10

$ conda activate kohya_ss

$ git clone https://github.com/bmaltais/kohya_ss

$ cd kohya_ss

$ sudo apt update -y && sudo apt install -y python3-tk               #python3-tk를 필요로 하는데 일반적으로 미설치되어있다

$ ./setup.sh

Skipping git operations.
Ubuntu detected.
Python TK found...
Switching to virtual Python environment.
22:33:35-474863 INFO     Python version is 3.10.14 (main, Mar 21 2024, 16:24:04) [GCC 11.2.0]                                                                                                                   

..

22:36:35-016860 INFO     Configuring accelerate...                                                                                                     
22:36:35-017576 WARNING  Could not automatically configure accelerate. Please manually configure accelerate with the option in the menu or with:       
                         accelerate config. 

위와 같은 accelerate warning이 뜨면 직접 실행해준다.

$ cd venv/bin

$ ./accelerate config

------------------------------------------------------------------------------------------------------------------------------------------------------In which compute environment are you running?
This machine                                                                                                                                           
-------------------------------------------------------------------------------------------------------------------------------------------------------Which type of machine are you using?                                                                                                                   
No distributed training                  #GPU가 여러개일 경우만 분산선택                                                                                                          
Do you want to run your training on CPU only (even if a GPU / Apple Silicon / Ascend NPU device is available)? [yes/NO]:  #계속엔터입력                           
Do you wish to optimize your script with torch dynamo?[yes/NO]:                                                                                        
Do you want to use DeepSpeed? [yes/NO]:                                                                                                                
What GPU(s) (by id) should be used for training on this machine as a comma-seperated list? [all]:all                                                   
-------------------------------------------------------------------------------------------------------------------------------------------------------Do you wish to use FP16 or BF16 (mixed precision)?                                                                                                     
fp16                                                                                                                                                   
accelerate configuration saved at /home/xxxx/.cache/huggingface/accelerate/default_config.yaml                                                        

$ cd ../..

/*------- 이때 Stable Diffusion의 최신 버전인 Flux.dev를 학습시키려고 하면 아래를 실행 후 다시 setup.sh를 실행하고 아니면 이 다음으로 ./gui.sh 실행으로 넘어간다.

$ git fetch origin

$ git checkout -b sd3-flux.1 origin/sd3-flux.1

$ git branch

  master
* sd3-flux.1 <-- 확인

$ pip install --use-pep517 -r requirements.txt

$ ./setup.sh

 이후 동일진행하되 이제는 나중에 fp16대신 bf16을 사용하고, nvidia이며 numa efficiency를 yes로 설정한다.

-------------------------------------------------------------------------------------*/

$ ./gui.sh

22:53:19-311775 INFO     Kohya_ss GUI version: v23.0.15                                                                                                
22:53:19-399403 INFO     Submodule initialized and updated.                                                                                            
22:53:19-402531 INFO     nVidia toolkit detected                                                                                                       
22:53:20-026297 INFO     Torch 2.1.2+cu118                                                                                                             
22:53:20-029252 ERROR    Could not load torch: cuDNN version incompatibility: PyTorch was compiled  against (8, 7, 0) but found runtime version (8, 5, 
                         0). PyTorch already comes bundled with cuDNN. One option to resolving this error is to ensure PyTorch can find the bundled    
                         cuDNN.Looks like your LD_LIBRARY_PATH contains incompatible version of cudnnPlease either remove it from the path or install  
                         cudnn (8, 7, 0)      

---------------------------------------------------------------------------------------------------------------------------

혹시 위와 같은 cudnn 라이브러리 오류가 나면 cudnn 8.7.0 for CUDA11.8을 NVIDIA에서 다운받아 설치해주자.

CUDA 폴더에 cudnn의 파일만 잘 복사해주면 된다.

$ tar xvfz cudnn-linux-x86_64-8.7.0.84_cuda11-archive.tar.xz       #nvidia 사이트에서 cudnn archive 다운로드가능

#아래와 같이 파일을 복사하여 설치한다.

$ sudo cp -P cudnn-linux-x86_64-8.7.0.84_cuda11-archive/include/cudnn.h /usr/local/cuda-11.8/include/
$ sudo cp -P cudnn-linux-x86_64-8.7.0.84_cuda11-archive/lib/libcudnn* /usr/local/cuda-11.8/lib64/
$ sudo chmod a+r /usr/local/cuda-11.8/lib64/libcudnn*

---------------------------------------------------------------------------------------------------------------------------

cudnn 버전 오류가 없다면 아래와 같이 gui.sh를 실행해서 웹서버를 띄우고, 웹에 접속한다.

$ ./gui.sh

0:35:53-556439 INFO     Kohya_ss GUI version: v23.0.15                                                                                                
00:35:53-578951 INFO     Submodule initialized and updated.                                                                                            
00:35:53-579987 INFO     nVidia toolkit detected                                                                                                       
00:35:54-373093 INFO     Torch 2.1.2+cu118                                                                                                             
00:35:54-377101 INFO     Torch backend: nVidia CUDA 11.8 cuDNN 8700                                                                                    
...                                                                                         
Running on local URL:  http://127.0.0.1:7860

실행 상태에서 브라우저를 띄워 http://127.0.0.1:7860 에 접속한다.

드디어 kohya_ss의 web UI가 뜬다.

이제 본격적인 학습을 위해 이미지를 준비하고 이 이미지의 script를 구할 차례다.

1. 학습에 추가시킬 이미지를 마련한다.

  대략 500*500 이상 해상도로 준비해두면, 자동으로 caption을 생성해서 학습에 사용할 수 있다. 특정 폴더에 모아두고, 시험목적이라면 10장 정도면 되겠다.

2. 자동으로 captioning(이미지별 설명을 담은 txt 파일 자동 생성)을 해보자.

 아래와 같이 Utilities->Captioning의 BLIP Captioning에서 image folders를 선택 한 후 맨 오른쪽 아래 Caption Images를 실행한다. 해당 폴더에 이미지와 같은 이름의 txt파일이 생겼음을 알 수 있다.

3. 이제 LoRA탭/Training중간의 Dataset Preparation으로 가보자. 오른쪽 화살표를 클릭해서 열자.

 Dataset Preparation설정 들 중에서 Instance prompt에는 이 LoRA를 활성할 특이한 이름을 넣고, Class prompt는 이 훈련을 하는 이미지들의 적당한 보통 명사를 지정한다. 그리고 가장 중요한 학습할 이미지의 폴더를 입력해주고, 이 모든 학습의 중간 데이터 등을 저장할 폴더를 하나 추가로 지정해주자(Destination training directory).

 그리고 차례로 하단의 'Prepare training data'버튼과 'Copy info to Folder Tab'버튼을 각기 차례대로 누르면, 학습할 이미지가 해당 destination folder로 이동되어 준비되고, 이 설정들이 상단의 Traing정보로 복사된다(캡춰 화면에서는 보이지 않는 위쪽에 반영된다)

3. Parameters를 변경한다

 그 다음은 이제 Parameters 를 열어서(Dataset Preparation바로 위) 아래와 같이 Presets를 sd15 - EDG_LoraOptiSettings로 예시 선택해보자. Epoch을 필요하면 약간 늘려준다. 4080으로 1 epoch당 몇분이 소요됨을 가정하자. 학습 진행 중에 대략 10GB전후의 GPU메모리가 사용되었다.

4. 맨 상단의 설정을 최종으로 정하자.

 그리고 맨 상단의 Pretrained model name은 적절히 기본 모델을 선택하자. 여기서는 sd-v1-5.safetensors 를 복사해두고 적용했다. 이 모델은 Stable Diffusion 유명한 기본 모델이며. 다른 모델을 써도 당연히 된다.

이제 맨 하단의 Start training을 누르면 학습이 시작된다.

 상기 케이스의 경우는 destination folder(/work2/kohya_ss/dest/)의 model 폴더에 75mb정도 크기의 safetensors형태의 LoRA모델이 생겼음을 알 수 있다. 이 만들어진 LoRA는 이제 Stable Diffusion에 잘 알려진 방법대로 원래 모델(여기서는 sd-v1-5.safetensors)과 함께 넣어 사용하면 되겠다. civit.ai의 LoRA들이 모두 이런 방식의 학습에 의해서 제공된다.

5. Flux.1 은 아래를 참고하자

개인비서 서비스가 LLM덕분에 가시권에 들어왔다. Siri도 그렇고 많은 사실은 많은 회사들이 이 개인비서를 꿈꿔왔다. 바쁜 현대인들은 대신 해줬으면 하는게 많기 때문이다. 인공지능이라는 이름으로 그동안 많은 서비스들이 이를 지향했는데, 사실 잘 안되었다. if-then 으로는 처리에 한계가 있었기 때문이다. 곧 사람들이 외면하기가 일쑤였다.

 그런데 LLM은 이미 OpenAI를 통해 어느정도의 사용자 경험을 인식시키고 있다. 청소년 정도의 응대만 가능해도 맡기고 싶은 일이 얼마나 많은가.

 하루를 한번 돌이켜보자. 몇시에 일어나서 밤사이 특별한 일은 없었는지(특히 해외 등), 날씨는 어떻고 우산을 가져갈지 말아야할지, 출근길에 특이한 정체나 사건은 없는지, 출근해서는 업무를 수행하기 위한 수많은 것들도 그렇고(임원들의 비서가 처리하는 수많은 것), 식당을 알아보고 일정을 조절하고는 기본이다.

 내 생활에서는 자녀를 위한 여러가지 교육 정보도 아쉽다. 내가 사는 지역에 특이한 일은 없는지, 내가 관심있는 주제는 어떤 변화가 있는지, 내 자산에는 알아야할 특이 정보는 없을지, 고민에 대한 상담, 여러가지 장기적인 관점의 진단은 특정 품질 이상으로 이런 것을 모두 챙겨줄 수 있다면 몇만원의 돈이 무엇이 아깝겠는가. 따라서 이 분야의 대형 서비스가 나올 수 있다고 생각한다.

 GPTs가 이런 비서 시장을 노릴테지만 여러가지 각각의 주제별로 조금더 전문화하고 다듬는 일이 필요하다. 그러다보면 각 전문분야별로 실제 정보나 컨텐츠가 부족하게 된다. 이러다보면 세상의 검색이나 여러가지 서비스가 API형태로 LLM이 쓸 수 있도록 변형되는 일이 가속화될것이다. 그렇게 더 발전하면 사람들이 직접 그 웹사이트에 들어가는 것보다는 API화 되어 LLM이 쓰는 양이 더 많아지고, 이제 사람들이 직접 사이트에 들어가는 것은 구식으로 느껴질 날이 올지도 모르겠다.

 이런 기술 환경의 핵심에는 Langchain같은 LLM을 다양하게 agent형으로 활용하는 오픈소스와 기존의 각종 서비스를 크롤링하고 API화되어가는 세상이 오는것. 비서 역할을 할 수 있는 사람이 있는 회사 임원들은 업무 사이트에 잘 들어가지 않는다. 사이트를 배우는 일도 큰 부담이기 때문이다. 이런 일을 LLM이 대신 해주는 세상이 곧 펼쳐지겠다.

 이런 변화가 오고있다. 영화 Her의 비서가 곧 세상을 점령해나갈 태세다.

Gemma 공개후 곧바로 파인튜닝 가능한 가이드가 공개되었다.

https://adithyask.medium.com/a-beginners-guide-to-fine-tuning-gemma-0444d46d821c

gemma-2b-it 모델의 quantized 버전 정도는 16GB GPU로도 파인튜닝 테스트를 해볼 수 있다.

상기 가이드대로 GPU환경에서 python을 설치한다.

$ conda create -n gemma python=3.11

$ conda activate gemma

$ pip install bitsandbytes==0.42.0
$ pip install peft==0.8.2
$ pip install trl==0.7.10
$ pip install accelerate==0.27.1
$ pip install datasets==2.17.0
$ pip install transformers==4.38.0

아래 소스를 통해 샘플 데이터 셋을 허깅페이스에서 다운받아 파인튜닝해서 결과를 얻어볼 수 있다.

이때 허깅 페이스에 미리 계정을 만든 후 WRITE 가능한 token으로 로그인을 미리 해두자. WRITE 권한으로 생성한 토큰으로는 모델을 huggingface에 업로드 하는 것도 가능하다(아래 소스의 맨 마지막 두줄)

$ huggingface-cli login
...
Token: 

$ huggingface-cli whoami
Justik (필자의 profile이다)

아래 코드를 실행한다. LORA를 통한 경량형 튜닝 정도는 할 수 있게 된다. gemma-7b-it의 경우는 16gb에서는 메모리가 부족하다. (본래 글에서는 A100을 추천하고 있다.) gemma-2b-it의 경우는 아래의 코드로 10~14gb정도의 메모리를 소모한다.

import json
import pandas as pd
import torch
from datasets import Dataset, load_dataset
from huggingface_hub import notebook_login
from peft import LoraConfig, PeftModel
from peft import LoraConfig, get_peft_model
lora_config = LoraConfig(
    r=64,
    lora_alpha=32,
    target_modules=['o_proj', 'q_proj', 'up_proj', 'v_proj', 'k_proj', 'down_proj', 'gate_proj'],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
) 
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    TrainingArguments,
    pipeline,
    logging,
)
from trl import SFTTrainer

notebook_login()

#model_id = "google/gemma-7b-it"
# model_id = "google/gemma-7b"
model_id = "google/gemma-2b-it"
#model_id = "google/gemma-2b"

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16
)

#model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=lora_config, device_map={"":0})
model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=bnb_config, device_map={"":0})
#model = AutoModelForCausalLM.from_pretrained(model_id, device_map={"":0})
tokenizer = AutoTokenizer.from_pretrained(model_id, add_eos_token=True)
{
    "instruction": "Create a function to calculate the sum of a sequence of integers.",
    "input":"[1, 2, 3, 4, 5]",
    "output": "# Python code def sum_sequence(sequence): sum = 0 for num in sequence: sum += num return sum"
}

dataset = load_dataset("TokenBender/code_instructions_122k_alpaca_style", split="train")

def generate_prompt(data_point):
    """Gen. input text based on a prompt, task instruction, (context info.), and answer

    :param data_point: dict: Data point
    :return: dict: tokenzed prompt
    """
    prefix_text = 'Below is an instruction that describes a task. Write a response that appropriately completes the request.\\n\\n'
    # Samples with additional context into.
    if data_point['input']:
        text = f"""<start_of_turn>user {prefix_text} {data_point["instruction"]} here are the inputs {data_point["input"]} <end_of_turn>\\n<start_of_turn>model{data_point["output"]} <end_of_turn>"""
    # Without
    else:
        text = f"""<start_of_turn>user {prefix_text} {data_point["instruction"]} <end_of_turn>\\n<start_of_turn>model{data_point["output"]} <end_of_turn>"""
    return text

# add the "prompt" column in the dataset
text_column = [generate_prompt(data_point) for data_point in dataset]
dataset = dataset.add_column("prompt", text_column)
dataset = dataset.shuffle(seed=1234)  # Shuffle dataset here
dataset = dataset.map(lambda samples: tokenizer(samples["prompt"]), batched=True)

dataset = dataset.train_test_split(test_size=0.2)
train_data = dataset["train"]
test_data = dataset["test"]

model = get_peft_model(model, lora_config)
trainable, total = model.get_nb_trainable_parameters()
print(f"Trainable: {trainable} | total: {total} | Percentage: {trainable/total*100:.4f}%")

import transformers

from trl import SFTTrainer

tokenizer.pad_token = tokenizer.eos_token
torch.cuda.empty_cache()
trainer = SFTTrainer(
    model=model,
    train_dataset=train_data,
    eval_dataset=test_data,
    dataset_text_field="prompt",
    peft_config=lora_config,
    args=transformers.TrainingArguments(
        per_device_train_batch_size=1,
        gradient_accumulation_steps=4,
        warmup_steps=0.03,
        max_steps=100,
        learning_rate=2e-4,
        logging_steps=1,
        output_dir="outputs",
        optim="paged_adamw_8bit",
        save_strategy="epoch",
    ),
    data_collator=transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False),
)

# Start the training process
trainer.train()

new_model = "gemma-2b-it-finetune" #Name of the model you will be pushing to huggingface model hub
# Save the fine-tuned model
trainer.model.save_pretrained(new_model)

# Merge the model with LoRA weights
base_model = AutoModelForCausalLM.from_pretrained(
    model_id,
    low_cpu_mem_usage=True,
    return_dict=True,
    torch_dtype=torch.float16,
    device_map={"": 0},
)
merged_model= PeftModel.from_pretrained(base_model, new_model)
merged_model= merged_model.merge_and_unload()

# Save the merged model
merged_model.save_pretrained("merged_model",safe_serialization=True)
tokenizer.save_pretrained("merged_model")
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"


def get_completion(query: str, model, tokenizer) -> str:
  device = "cuda:0"
  prompt_template = """
  <start_of_turn>user
  Below is an instruction that describes a task. Write a response that appropriately completes the request.
  {query}
  <end_of_turn>\\n<start_of_turn>model
  
  """
  prompt = prompt_template.format(query=query)
  encodeds = tokenizer(prompt, return_tensors="pt", add_special_tokens=True)
  model_inputs = encodeds.to(device)
  generated_ids = model.generate(**model_inputs, max_new_tokens=1000, do_sample=True, pad_token_id=tokenizer.eos_token_id)
  # decoded = tokenizer.batch_decode(generated_ids)
  decoded = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
  return (decoded)

result = get_completion(query="code the fibonacci series in python using reccursion", model=merged_model, tokenizer=tokenizer)
print(result)


# Push the model and tokenizer to the Hugging Face Model Hub
# merged_model.push_to_hub(new_model, use_temp_dir=False)
# tokenizer.push_to_hub(new_model, use_temp_dir=False)

이렇게 hugging face hub에 올려진 모델은 아래와 같다.

https://huggingface.co/Justik/gemma-2b-it-finetune

역대의 물리학 혁명을 거론할때 빼놓을 수 없는 주제가 바로 중력이다.

 가장 위대한 물리학자를 꼽으라는 투표에서 흔히 등장하는 것이 뉴튼, 맥스웰, 아인슈타인인데, 뉴튼과 아인슈타인이 같이 연결된 것이 바로 중력이다. 물리학이 천문학에서 유래했다면, 별들을 예측하는데 가장 중요한 발견이 중력에 대한 것이다. 그러나 이 중력을 둘러싼 해석은 역사적으로 다양했고, 아인슈타인이 등장한 이후에야 비로소 통일된 해석을 시작했다.

 무슨 이야기일까?

 다시 한번 숨을 가다듬고 생각해보자. 이 알 수 없는 우리 눈앞에 보이는 예컨데 "공", 다시 말하자면 "질량"이라는 것은 무엇일까?

 손으로 잡은 후, 멀리 던지면 땅에 떨어지는 이 무언가에 대한 이야기다. 가만히 생각해보면 우리는 이 존재를 아래 두가지로 인지할 수 있다는 것을 경험상 알고 있다(그리고 이는 뉴튼이 맨 처음 수학적으로 정리한 형태이기도 하다)

1. 밀거나 멈추는데 힘이 들어간다(F = ma, 관성질량)

2. 두 질량이 있는 존재는 서로 당긴다(뉴튼의 중력 계산, F = G * m1 * m2 / r^2, 그래서 지구쪽으로 떨어진다. 중력질량)

 그리고 당연히 인류는 아인슈타인 이전까지 이 둘을 이렇게 서로 다른 것으로 정의해서 사용하였다. 어떤 이들에게는 사실 같아 보이는데, 사실은 전혀 다른 것이라는 것을 알 수 있다. 어떻게 해도 둘을 같게 해석할 수가 없다. 공을 빠르게 하는데 힘이 들어간다는 사실이, 두 공이 서로 당긴다는 사실과 연관짓기가 힘든 것이다.

 이는 물리학자들에게 각기 관성질량과 중력질량으로 구분되었고, 초기에는 이 둘이 같다는 여러가지 증명하려는 시도가 있었다. 피사의 사탑에서 무거운 공과 가벼운 공을 낙하시키는 실험이 그렇다. 중력과 가속도가 동시에 반영되는 상황에서는 그래서 질량에 상관없이 동일한 운동을 보인다. 공기가 없는 와중에 포물선을 그리며 날아가는 공도 그러하다. 그것들은 본래의 질량과 관련이 없다. 관성 질량과 중력 질량은 마치 동일한 것처럼 작동한다는 사실에 늘 과거의 물리학자들은 의아해했다.

 그런데 이 둘을 합쳐서 생각해볼 수 있는 방식이 존재한다. 그것은 대체 어떤 것일까? 가속하기 어렵다는 사실과 두 질량이 서로를 당긴다는 사실을 어떻게 하나의 원리로 바라볼 수 있을까?

여기에 아인슈타인이 주장했던 등가 원리(equivalance principle)는 그 중요한 열쇠가 된다. 즉, 엘레베이터 안에 갇혀있어서 밖을 볼 수 없는 상황에서는 이 두가지를 구별할 수 없다는 이야기다.

 밖에서 엘레베이터를 누가 밀어서 가속하면, 그 안의 내가 뒤로 밀릴텐데 이것이 가속에 의한 것인지, 아니면 지구같은 어떤 큰 질량이 옆에 있어서 중력에 의해 그렇게 되는지 알 수 없다는 사실이다. 이것이 바로 아인슈타인의 깨달음이며 등가원리의 기본이다. 그 둘을 구별할 수가 없다. 질량의 존재가 가속을 방해하거나 질량끼리의 당기는 힘을 만들어내면 된다.

 어떻게 이런 것이 가능할까? 놀랍게도 바로 질량이라는 것이 시공간을 휘면 그렇게 된다. 특수 상대성이론 등 여러가지 속에 그 기초를 닦은 아인슈타인은 그렇게 이 질량을 바라보는 시각을 혁신했다.

 그렇다. 질량은 시공간을 휜다. 그렇게 두 질량이 시공간을 휘면 서로에게 다가가려고 하는 방향으로 움직인다. 그것이 가장 자연스러운 상태이기 때문이다. 홀로 있을때는 어떠한가, 시공간이 휘면서 질량은 스스로를 감가속이 없는 상태로 유지하고자 하기 때문에(자기 스스로에게 낙하) 가속에는 힘이 들게 된다. 질량이 단독으로 존재 할 때도, 여러 질량이 같이 있을때도, 시공간의 휘어진 형상은 이 질량은 가속하기 어렵게 또한 서로에게 당겨지도록 하는 힘의 장을 만들어낸다. 아인슈타인의 장 방정식(Field Equation)이다.

 아래의 계량 텐서는 각 공간의 구조를 결정짓고, 이는 각 요소들간의 미분관계를 담는 리치 텐서와 질량/에너지의 분포를 다룬 스트레스-에너지 텐서를 통해 결정된다.

 이렇게 통합되어 설명하고 나면, 시공간의 휘어짐이 임계치를 넘는 블랙홀이라던가, 거대 질량 주변의 시간이 느리게 간다던가 하는 효과를 모두 계산할 수 있게 되었고, 지금은 관성질량/중력질량으로 구분해서 이해하던 시기보다도 훨씬 더 대규모의 자연 현상을 정확하게 계산할 수 있게 된 것이다.

 즉 관성질량과 중력질량이라는 두가지 관점을 장방정식으로 풀어낸 것이 아인슈타인의 업적이 되겠다. 서로 다른 두개를 하나의 틀에서 볼 수 있게 되자 기존의 상황이 더 명확해졌고, 훨씬 더 극단적인 상황에서의 예측이 가능해지게 된 것이다.그곳에는 공간의 휨뿐만 아니라 시간까지도 고려되어야 한다는 것이 그의 결론이 된 셈이다. 그렇게 그의 업적을 바라볼 수가 있다. 인류 역사의 기록에 남겨진, 기막힌 통찰의 순간 중의 하나이다. 우리가 향후에 또다른 통합된 이론을 가지게 된다면 왜 그때는 이것이 서로 같다는 것을 몰랐을까 라고 한탄할 주제에 대한 사전 예시가 아닌가.

 장방정식 관련해서는 아래 차동우 교수의 짧은 강의를 참고해보자.

https://www.youtube.com/watch?v=E3o1KahfWMw&t=1204s

 일반인에게는 조금 낯설 수도 있지만, 세기의 천재를 지칭할때, 물리학자들은 제임스 맥스웰(James Clerk Maxwell, 1831~1879)을 빼놓지 않는다. 그는 이 블로그에 있는 맥스웰의 도깨비를 창조해낸 인물이기도 하지만, 전자기학의 수학적 체계를 완성한 시조격으로 불리기도 한다.

 결론적으로 이야기하면 그는 전자기와 빛에 관한 이론 통합된 관점을 제공했다.

 맥스웰이 활동하던 시기는, 전기와 자기, 그리고 빛은 모두 서로 다른 존재였다. 자석으로 나침반을 만들었고, 특정 상황에서 발생하는 전기에 대해 연구하였고, 따로 광학이 연구되었지만 서로간의 그 상관관계가 있다는 것은 정확히 알지 못했다.  그런 와중에 맥스웰은 아래와 같은 방정식으로 전기와 자기의 성질에 대해 과거 학자들의 내용을 미적분으로된 방정식으로 정리했다. 패러데이가 실험만으로 전자기 유도 현상을 설명한 것과 다르게 이론 체계를 잡은 것이다.

 그리고 그 내용은 아래와 같다.

1. 어떤 전하를 둘러싼 닫힌 곡면을 통해 나가는 전기력선 수는 그 전하에 의해 결정된다(전기력, 쿨롱의 법칙, E는 전기장, 전하는 음극이나 양극 단독으로 존재해서 힘을 발휘한다)

2. 임의의 폐곡면을 나가는 자기 선속이 0이다(자기력, N극이나 S극은 독립해서 존재하지 않는다. 자기력은 나가면 다시 돌아온다. B는 자기장)

3. 자속 밀도의 시간에 따른 변화는 전기장을 생성한다(패러데이의 유도 법칙, E와 B의 관계)

4. 시간에 따라 변화하는 전기장과, 전류에 의해 자기장 변화를 나타낸다(from 앙페르의 법칙, 외르스테드)

 재미있는 것은 이 법칙들에 의해서 공간 속에서 전기와 자기가 서로를 유도하며 전파되는, 전자기파 파동방정식이 유도된다는 사실이다. 그리고 그 전자기파의 진행 속도는 '광속'과 같다. 이 모든 것을 단순한 방정식으로 정리하고 증명한 것이 맥스웰의 업적이다.

 그이전에 인류는 자석과, 전기, 빛이 서로 독립적으로 움직인다고 생각했는데, 맥스웰은 상기 4개의 방정식으로 정리한 후 이를 통해 전자기 파동의 파동방정식을 유도해내고, 그것이 서로 영향을 주는 얽혀있는 현상이라는 것을 입증하고 수학적으로 나타낸것이다. 그리고 이 결과에 의해 전자기파 파동이 존재하고, 그 속도는 광속인 것. 즉 빛이라는 것이 전자기파 현상이라는 것을 입증한 셈이다.

 그렇게 인류는 이 알 수 없는 현상들을 하나로 설명해낼 수 있게 되었고, 이는 모든 무선 통신과 전기/자기의 제어에 대한 예측이나 계산을 할 수 있게 된 것이다. 리처드 파인만은 이러한 맥스웰의 업적을 인류 문명의 발견 중에 가장 중요한 것 중의 하나로 꼽았다. 아인슈타인의 중력에 대한 해석과 함께, 인류사의 자연에 대한 통합 해석에 한 획을 그은 사건이라고 볼 수 있다.

리처드 파인만 (1964): "인류의 역사를 장기적으로 보면, 예를 들어 지금으로부터 10,000년 후로 볼 때 19세기의 가장 중요한 사건이 맥스웰의 전기역학의 법칙 발견으로 평가될 것이라는 데는 의심의 여지가 없다. 미국 남북 전쟁은 같은 10년 동안 일어난 맥스웰의 중요한 과학적 사건과 비교할 때 변방의 무의미한 사건으로 변할 것이다.", 인용 : https://ko.wikipedia.org/wiki/%EC%A0%84%EA%B8%B0%EC%99%80_%EC%9E%90%EA%B8%B0%EC%97%90_%EA%B4%80%ED%95%9C_%EB%85%BC%EB%AC%B8%EC%A7%91

아래는 관련해서 김갑진 교수의 설명을 담은 youtube영상이다. 그의 업적을 살펴보자.

https://www.youtube.com/watch?v=OTF-oP7io_M&t=710s

 처음에 양자 컴퓨터를 상상하면 지금의 컴퓨터보다 훨씬 나은, 대체되는 무엇인가를 상상하게 된다. 다른 운영체제가 설치되고 작동방식도 완전히 다른, 새로 사야하는 컴퓨터 말이다. 그리고 이때 또다른 헷갈리는 말은 qubit이다. 중첩을 설명하려고 나온 이 qubit은 정작 일반 엔지니어들이 이 양자 컴퓨터의 실제를 이해하는 것을 처음에는 방해한다고 생각한다.

  그런데 실제 양자 컴퓨터는 아래 그림처럼 상상해볼 수 있다. 여기서 핵심은 오른쪽 컴퓨터와 모니터는 현대의 PC 그대로이고 왼쪽의 양자를 구성 및 관측하는 usb로 연결된 보조 기기가 달려 있는 모습이 실제 형상이라는 점이다. 즉 양자 컴퓨터는 기존의 PC가 완전히 바뀌는 것이 아니라, 단순히 기존 PC에 양자관측 장치를 붙인 모습이다.

 그리고 그러면 왜 그런 부가 장치가 이 PC를 양자 컴퓨터라는 존재로 만들어줄까?

 예를 들면 어떤 '공(ball)'을 특정 각도와 힘으로 던져서, 어떤 분자들이 가득한 대기 상태를 지나 착지하는 지점을 계산하는 작업이 필요하다고 하자. 그런데 그 계산이 뜻하지 않게, 매우 엄밀하게 대기의 모든 분자를 고려해야 한다면 또 어떨까? 이런 경우는 말 그대로 그 계산에 지나치게 많은 시간이 든다. 대기중에 존재할 10의 수십 제곱쯤 되는 분자들을 하나하나 계산에 포함해야 한다면 말이다. 그러면 어떤 우회 방법이 있는가? 조금 무리해보일지라도, 실제로 그러한 환경을 정확히 실제로 구성해서 관측해서 사용하는 방법이 있다. 계산을 하지 않고 계산 값을 자연으로부터 직접 훔치는 방법이다. 물론 매우 정확하게 대기 상태를 조성하고, 정확한 방향으로 정확한 힘으로 던져서 정확하게 측정해야 하는 말도 안되는 난해함이 있겠지만, 그것만 해결하면, 대기중에 존재할 그 모든 분자상태를 고려한 계산을 하려면 걸릴 수년의 시간보다, 공을 던져서 떨어지는 정도의 시간밖에 소요되지 않는다.

 그리고 이는 정확히 양자 컴퓨터의 원리나 어려움과 비교되어 설명될 수 있다. 양자 컴퓨터는 양자적인 현상을 직접 실제와 같이 구성하고 관측하는 방법에 기초한다. 어마어마한 계산이 필요한 일을 자연을 직접 관측해서 해결하는 것이다. 이 아이디어는 맨 처음 리처드 파인만 교수에 의해 제안되었다고 알려져있다. 양자들이 너무 많이 얽혀 있는 경우는 계산에 너무 오래 걸리니까 계산을 하지 말고, 직접 해버리면 되잖는가?

  그런데 이점은 놀랍지 않은가? 엄청난 계산이 필요한 작업도 자연은 금방 해낸다는 점이다. 사실은 고전 컴퓨터도 자연의 원리를 해킹한 것과 같다. 전기적인 신호의 원리를 활용하여, 즉 트랜지스터라는 전자적 스위치를 확장하여 입력과 출력을 제어하고, 그것들에 규칙을 설정하여 현대의 컴퓨터는 어떤 계산도 할 수 있도록 구성되어 있다. 그런데 이 전기/전자 원리에 의한 현대의 디지털 컴퓨터의 한계는 어떤 특정한 계산을 해내려면 너무나 오랜 시간이 걸리도록 반복하는 작업이 필요하다는 한계가 있다.

 그러면 아예 자연이 하는 복잡한 계산인 양자의 계산력을 훔쳐오면 어떨까? 물론 그 계산이 우리가 원하는 모든 계산은 아니지만, 특정한 상황에서 그 값을 써먹을 수 있다면 어떨까? 그 계산만이라도 가속할 수 있지 않겠는가?

 바로 그런 상상이 양자 컴퓨터를 상정하게 만들었다. 그러면 대체 무엇을 자연에서 관측하는 것이고, 어떤 계산을 빠르게 할 수 있는 것일까? 여기서는 이미 양자 컴퓨터가 기존의 PC에다가 다량의 양자 구성/관측 장치를 연결하는 것이라고 밝혀두었기 때문에 이 양자 구성/관측 장치에 대해서 살펴보자.

1. 양자 구성/관측 장치가 하는 일

 이 장치를 설명하는 핵심은 양자 중첩과 얽힘이다. 이 부분의 깊은 영역은 아래 section에서 다루도록 해보자.

https://infoengineer.tistory.com/3

 양자는 미시적인 소재는 무엇이든 가능하다. 전자/양성자/원자/광자/.. 무엇이든 양자역학적으로 작동하면 그래서 양자역학의 구성/관측 장치로 만들어볼 수 있다.

 즉, 파동의 형태로 존재하는 이 입자들은 관측되기 전에는 확률로 존재하다가, 관측되면 확정되는 과정을 거치는데, 이 입자들이 얽혀있는 특정한 상태가 되면, 이 수많은 입자들이 한꺼번에 확정된다. 이를 테면 양자 100개를 얽히게 어떤 특정 관계로 만든 다음에 관측하면, 단 1 cycle에 그 모든 양자들의 상태가 확정된다.

 이 각 양자를 qubit이라고 부르는데, 어떤 관계를 구성(양자 회로 구성)한 후에 몇번을 반복해서 관측해보면, 이 전체 상태가 가지는 대략의 확률 분포를 알 수 있다. 즉 대략 결과값을 알 수 있다.

 그리고 이 "확률 분포"는 어떤 복잡한 계산을 하는 힌트가 된다. 그 높은 확률을 따라가면서 다음 단계를 진행하다보면, 수만년이 걸릴 계산이 몇 초로 줄어들 수 있다는 것이 이 양자 구성/관측 장치의 응용 핵심이다.

 그래서 양자 컴퓨터는 대략 이런 과정을 거쳐서 계산을 완료할 수 있다.

 A. 다량의 양자를 가지고 어떤 관계를 구성한다(양자 회로 구성).

 B. A를 반복해서 만들고 관측을 원하는 만큼 반복해서, 확률 분포를 구한다. 기본적으로 qubit이 많고 오차가 클 수록 더 많이 반복해서 정확한 확률 분포를 구한다.

 C. 그 확률에 따라 다음 연산을 구성하고, 다시 A로 돌아간다.

 D. 중간중간 그 확률을 따라간 결과가 맞는지 확인하다가 답이 맞으면 멈춘다.

 따라서 양자 컴퓨터는 모든 종류의 계산을 빨리하지 못한다. 흔히 이야기하는 범용 컴퓨터가 아니다. 이 양자 회로의 관측 값의 확률 분포로 가속할 수 있는 계산만 가속할 수 있고, 그런 계산이 아직 많이 발견된 것은 아니다. 몇가지 이 고속 계산화 가능한 분야의 몇개의 알고리즘이 알려져 있고, 가장 유명한 것이 바로 피터 쇼어 알고리즘, 즉 소인수 분해 알고리즘이다.

2. 소인수 분해 알고리즘은 어떤 것인가?

 이 소인수 분해를 양자 컴퓨터로 고속화 하려면, 먼저 소인수 분해 과정을 양자 컴퓨터에 맞는 것으로 바꾸고, 그 분해 과정 중 특정 계산을 위해 양자 구성/관측을 해야한다.

 이 소인수 분해 알고리즘에 대한 설명은 아래 영상에서,

https://www.youtube.com/watch?v=gjp9301in0U

 이 알고리즘을 양자 컴퓨터로 회로화하여 구하는 것은 이 아래 영상에서 참조해볼 수 있다.

https://www.youtube.com/watch?v=qV3k-bQgmK0

이 알고리즘은 이해하기 까다롭지만, 결론은 그렇다. 양자 회로(양자를 얽힘 상태로 특정 관계를 갖게 구성)를 만들고 그 관측을 여러번 해서 나오는 확률 값들로 어떤 계산을 가속할 수 있다는 점이다. 그리고 어떤 회로 구성으로 어떤 계산을 가속할지는 지금도 계속 연구하고 있다. 아직 응용 분야는 적다. 탐색/최적화/소인수분해/양자시뮬레이션 등이 알려져있다.

3. 양자 컴퓨터는 어떤 방식으로 만들어지는가?

 양자는 그야말로, 양자 하나씩을 다뤄야 하니 기술적인 난이도는 엄청나다. 외부와 차단시켜 결잃음(간섭이나 관측)을 최종 순간까지 막아야 하기 때문에, 대부분의 방식에서 절대온도 0도 가까운 냉각이나 진공 등의 이슈가 나온다. 회로를 구성하기 위해서 양자 하나하나를 제어하는 것도, 그리고 하나하나 관측하는 것도 쉽지가 않다. 광자는 상온에서도 다룰 수가 있지만 도대체 광자 하나를 측정한다는게 너무 어려운게 현실이다.

 이 부분에 대한 이해는 아래 영상을 추천해본다.

https://www.youtube.com/watch?v=Gem0N1JEm9k

실제로 양자 컴퓨터는 이미 이러한 회로 구성과 관측 들이 모두 클라우드 API로 제공되고, 에뮬레이터도 같이 제공된다. 에뮬레이터는 근사 확률값을 조금 느려도 계산해주는 역할을 한다. 실제 양자 컴퓨터가 작동한다고 하면 수천/수만개의 큐빗을 구성해서 우리는 단 한번의 싸이클로 그 값을 관측할 수 있다. 그렇게 다수 관측한 값을 가지고 특정 계산을 빠르게 하는 셈이다.

위 영상들이 일반인도 짧은 시간안에 양자 컴퓨터를 개괄할 수 있는 한국어로 된 좋은 내용이라고 생각되어 정리해본다.

여러가지 다양한 오픈소스 모델이 쏟아지고 다양한 구동방법이 나오는데, 대부분은 HuggingFace를 통해 배포되고 있다.

이에 최근에 좋은 성능을 보인다고 알려진 SOLAR 10.7B 한글 튜닝 모델인 megastudy SOLAR 10.7B 모델을 구동해보자.

SOLAR 10.7B는 24GB이상의 GPU메모리에서 가동이 가능한 점은 참고가 필요하다.

여기서는 다양한 LLM을 연결해서 실행할 수 있는 langchain 프로젝트의 도움을 받는다.

$ conda create -n solar10.7b python=3.11

$ conda activate solar10.7b

$ pip install langchain langchain_community huggingface_hub transformers sentencepiece torch datasets

1. HuggingFace 가입 및 access token받기

우선 huggingface와 langchain으로 연계시키려면 access token이 필요한데, 가입 후 발급받으면 된다.

https://huggingface.co/settings/tokens

여기서 받은 토큰을 아래와 같이 환경변수에 추가한다.

$ export HUGGINGFACEHUB_API_TOKEN="발급받은huggingface토큰"

여기서는 아래 모델을 사용해보자. 자동으로 모델을 다운로드 받아 실행하므로 langchain이 지원하는 대부분의 모델을 실행해 볼 수 있다.

https://huggingface.co/megastudy/M-SOLAR-10.7B-v1.3

2. LangChain을 통해 HuggingFace 모델을 실행해보자.

아래와 같이 실행한다.

$ cat > testlangchain.py

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain_community.llms import HuggingFacePipeline

# HuggingFace의 model id를 삽입한다.
#model_id = 'mncai/mistral-7b-v5'
#model_id = 'maywell/Mistral-ko-7B-v0.1'
model_id = 'megastudy/M-SOLAR-10.7B-v1.3'


# HuggingFacePipeline object
llm = HuggingFacePipeline.from_model_id(
    model_id=model_id, 
    device=0,               # -1: CPU(default), GPU존재하는 경우는 0번이상(CUDA Device #번호)
    task="text-generation", # 텍스트 생성
    model_kwargs={"temperature": 0.1, 
                  "max_length": 128},
)

# template
template = """질문: {question}

답변: """

prompt = PromptTemplate.from_template(template)
llm_chain = LLMChain(prompt=prompt, llm=llm)

question = "서울에서 제일 유명한 산이 어디야?"
print(llm_chain.run(question=question))

아래와 같이 실행하면 모델을 local로 다운로드 받아 잘 구동하는 것을 알 수 있다.

$ python testlangchain.py

...
  warnings.warn(
tokenizer_config.json: 100%|███████████████████████████████████████████████████████████████████████| 1.46k/1.46k [00:00<00:00, 4.00MB/s]
tokenizer.model: 100%|███████████████████████████████████████████████████████████████████████████████| 493k/493k [00:00<00:00, 27.0MB/s]
special_tokens_map.json: 100%|█████████████████████████████████████████████████████████████████████████| 551/551 [00:00<00:00, 1.50MB/s]
config.json: 100%|█████████████████████████████████████████████████████████████████████████████████████| 720/720 [00:00<00:00, 1.81MB/s]
model.safetensors.index.json: 100%|█████████████████████████████████████████████████████████████████| 35.8k/35.8k [00:00<00:00, 182kB/s]
model-00001-of-00005.safetensors: 100%|██████████████████████████

..

서울에서 가장 유명한 산은 북한산입니다. 북한산은 서울 북쪽에 위치한 아름다운 산으로 많은 사람들이 등산하고 휴식을 취하는 곳입니다.

기타로 "IT개발팀에 새로 팀장이 되었는데, 팀원들을 북돋워줄만한 연설문을 써줘." 라고 질문하고 max_length를 2048로 하면,

"팀장 선임을 축하합니다! 저희 팀은 팀원들의 헌신과 노력으로 성공을 거두어 왔습니다. 저는 저희 팀의 새로운 팀장으로서 저희 팀원들의 헌신과 노력에 감사드리며, 저희 팀의 미래를 위해 함께 노력하겠습니다. 저희 팀은 ..." 라고 답변한다.

또한 llangchain은 openai API를 동일한 방식으로 연계해서도 사용할 수 있어서 다양하게 활용이 가능하다. GPU 메모리가 부족하다면 모델을 바꾸거나(주석의 #model_id = 'mncai/mistral-7b-v5' 참조), HuggingfacePipeline변수내 device=-1로 변경(CPU로 실행)하여 전환하여 실행해서 실험해볼 수 있다.

---------------------------------------------------------------------------------------------------

# HuggingFace의 model id를 삽입한다.
model_id = 'mncai/mistral-7b-v5'
#model_id = 'megastudy/M-SOLAR-10.7B-v1.3'


# HuggingFacePipeline object
llm = HuggingFacePipeline.from_model_id(
    model_id=model_id, 
    device=-1,               # -1: CPU(default), GPU존재하는 경우는 0번이상(CUDA Device #번호)
    task="text-generation", # 텍스트 생성
    model_kwargs={"temperature": 0.1, 
                  "max_length": 128},
)

---------------------------------------------------------------------------------------------------

 소프트웨어 개발일을 하다보면, 이 컴퓨터가 어떻게 이렇게 잘 작동하는지 궁금해질 때가 있다. 언제나 같은 결과를 내놓고, 그리고 잘 "작동"한다.

 원래 그런 것으로 받아들이면 별로 관심 둘 일이 없지만, 생각해보면 신기한 일이다. 대체 이 계산력의 근간은 무엇일까? 과거에 톱니바퀴를 돌려 덧셈을 계산하던 계산기는 눈으로 보이기라도 하지만, 컴퓨터의 계산은 눈에 잘 보이지도 않는다. 그런데 어떻게 이렇게 "계산"을 잘 실행할 수 있을까?

 정답은 "자연의 계산력을 해킹한다"는 점이다. 기본적으로 톱니나 전자 소자도 마찬가지다. 자연의 물리 법칙에 맞게 작동하는 존재의 법칙 준수를 그대로 이용하는 것이다. 이는 최근의 양자 컴퓨터도 마찬가지인데, 현대의 모든 계산기는 자연 법칙의 일관된 작동에 기반하게 된다.

 톱니바퀴에 의한 계산기부터 살펴보자. 가장 간단한 것은 덧셈이다. 5+6=11이라는 것은 누구나 암산 할 수 있지만, 이것은 사람의 뇌의 힘을 빌어서 할때는 그렇다. 기계적으로 이 덧셈을 하려면 어떻게 할까? 가장 손쉽게 설명할 수 있는 것이 바로 "기계식 시계"이다. 기계식 시계는 세상에서 가장 오랫동안 개선 되어온 톱니 계산기 중의 하나이다. 60초는 1분이며 60분이 1시간이 되는 기본 구조를 가지고 초침과 분침이 돌며 숫자를 가리킨다. 즉, 60초가 되어 톱니가 한바퀴 돌면 더 큰 톱니를 움직여 1분을 더해주고, 그 1분이 60분이 지나 결국 더 큰 톱니를 조금더 움직여 1시간을 나타낸다. 60진법 덧셈 계산기인 것이다. 아래가 그 태엽에서 시작된 동력이 어떻게 초/분/시가 연결되어 나타내지는 보이는 구조이다. 각 축에는 시침,초침,분침이 연결된다. 맨 상단의 메인 스프링통이 돌면서 첫번째 휠이 아주 천천히 돌 것이고(시간), 그 정확한 비에 의해서 다음 휠이 그 다음 속도로 돌고, 또 그 다음 휠이 그 다음 속도로 된다. 그 비율은 1:60으로 고정되어 있다. 맨 하단에는 이 휠이 일정한 속도로 돌도록 일종의 진자 역할을 하는 밸런스 휠이 붙어 있다.

상기의 Second Wheel이 시침이며, Third Whell이 분침, Fourth Wheel이 초침이며 실제로는 아래와 같이 좀더 복잡하게 붙어있다. 그리고 시계의 맨 앞판에는 실제로 숫자와 눈금이 있어 우리가 숫자를 읽게 된다.

 여기서 사용하는 자연의 법칙은 무엇인가? 단순한 물리 법칙이다. 톱니와 톱니가 맞물려있고, 그 돌아가는 비에 따라서 톱니가 다른 속도로 회전한다. 거기에 단순히 시침,분침,초침을 달아서 읽어 내면, 60진법의 덧셈을 하는 기계를 목격하게 되는 셈이다. 그리고 한마디 덧붙이면 이 계산기는 현대의 전자식 계산기에 비하면 효율이 떨어진다. 톱니가 많아지면 돌리기 어려울 뿐 아니라, 정확한 비율로 톱니가 깍여있지 않으면 많이 돌렸을 경우에 오차가 생기게 된다.

 그리고 1950년대 이전의 컴퓨터는 모두 위의 톱니를 사용하거나 아니면 전기의 힘을 일부 차용했다(진공관). 톱니가 아니고 어떤것으로 계산이 가능하지?

 놀랍게도 1950년대에 AT&T 벨 연구소에서 개발한 트랜지스터를 조합하면 이제 전기와 전자를 통해 이 계산을 수행할 수 있게 된다. 물리적인 힘이 아니라 전자적인 힘이기 때문에 효율이 매우 높다. 고속으로 계산할 수 있는 시대가 열린 셈이다.

 톱니의 회전에 의한 덧셈은 직관적이라서 쉽게 이해가 가지만, 과연 이 트랜지스터를 가지고 어떤 계산을 하는지 의아해 할 수 있다. 그러나 현대의 디지털 회로는 AND, OR, NOT 정도 구현할 수 있다면, 입력에 대한 다양한 출력을 제어할 수 있다. 그리고 이 AND, OR, NOT을 전기를 흘러서 변형하도록 할 수 있도록 하는 것이 바로 이 트랜지스터이다. 전기가 흐르지 않는 것을 0, 5V가 흐르는 것을 1로 약속하고, 트랜지스터를 적절히 배열하면, 입력되는 전기에 대해 출력되는 전기를 아래와 같이 제어할 수 있다.조금 더 단순화하면 이 트랜지스터는 전자적인 스위치이다. 사람이 손으로 선을 끊거나 이어주지 않아도, 전기를 흘리거나 흘리지 않는 방법으로 전기의 차단 여부를 결정할 수 있다. 즉 모든 입력에 대해 출력을 마음대로 바꿀 수 있게 된 셈이다. 그리고 이것을 회로 기판에 직접 그려서 고정시키면 H/W라고 표현하고, 더 복잡한 방식으로 구성해서, 이 논리회로 구조를 메모리에서 읽어서 소프트웨어적으로 바꿀 수 있게 만들어주면(즉 가변 회로) 그것이 바로 프로그램이 된다. 현대의 폰노이만 체계에 의해서, 이 디지털 논리회로는 프로그램에 의하여 입력/출력을 바꿀 수 있게 된 것이다. 그것이 현대의 컴퓨터이다(프로그램 내장방식까지 더해져서 편리함이 엄청나다. 예전에는 회로의 기능이 바뀌면, 배선을 손으로 다시 해주거나 회로 기판을 다시 만들어야 했다!)

  하지만 이 복잡한 이야기 속에도, 그 근간에는 역시 전기와 전자의 물리적인 자연 법칙이 작동하는 것을 인간이 이용한다는 면에서는 자연을 해킹하는 것과 역시 같다. 그러면 여러분 만의 컴퓨터를 만드려면 어떻게 해야하는가?

 간단하다. 물리 법칙의 어딘가를 빌려다가 그 값으로 계산을 하면 된다. 오래된 되었지만 최근의 흥미롭게 다뤄지는 사례가 바로 아날로그 컴퓨터이다. 디지털 컴퓨터는 상기 0과 5V의 전압 차이를 가지고 0과 1로 단순화해서 계산한다. 그런데 그렇게 하면 여러 사이클을 반복하면서 계산해야 한다. 그런데 어차피 계산 값만 확보하면 되니, 0~10V를 각각 0에서 10이라고 가정하고 계산하면 더 빨리 계산할 수 있지 않을까? 저항을 나누고 싶은 값이나 곱하고 싶은 값으로 적절히 설정하면 된다. 이렇게 하면 장점은 매우 빠르게 계산할 수도 있다. 디지털 컴퓨터로는 수많은 사이클을 거쳐야만 하는 계산이, 회로를 한번만 작동시키면 값이 나오기 때문이다. 이를 잘 설명해주고 있는 것이 아래 베리타시움 채널이다.

https://www.youtube.com/watch?v=9ROD_oxpVcA

 그러면 양자 컴퓨터는 무엇일까? 바로 양자의 물리 법칙을 해킹해서 자연의 계산력을 가져오는 것이다. 이 양자의 물리 법칙이 보여주는 계산력은 대단하다. 어느 정도냐면, 몇가지 변환을 거치면 소인수 분해를 매우 빨리 할 수 있다. 기본적으로 자연의 계산력이라는 것은 소인수 분해를 고속으로 할 수 있었던 것이다.

 그래서 미래의 컴퓨터라는 것은 모두 이렇게 정의해볼 수 있다. 자연의 계산력을 훔쳐 쓰는 장치다. 사람의 암산은 그럼 다를까? 사람의 암산도, 신경세포의 조합에 의한 화학과 전기 법칙의 기반하에 작동하고 있고 역시 사람의 연산도 자연의 물리법칙을 차용한 셈이다. 결국 우리의 모든 계산력은 자연을 빌려다 쓰는 셈이다. 어떻게 돌려서 만들고 싶어도, 자연의 법칙에 의존하지 않는 계산기는 아직까지는 공식적으로 발견된 적이 없다고 할 수 있겠다.

 이런 시각은 어떤 면에서 도움이 될까? 바로 현대의 디지털 컴퓨터를 우리가 지배적으로 사용하고 있지만, 그것이 사실은 매우 특수한 형태였다는 점이다. 원래 자연을 어떻게든 해킹해서 더 다양한 컴퓨터를 만들 수 있었다. 많은 이들이 그런 상상을 해왔다면 현대는 더 다양한 컴퓨터들로 가득했을지 모르겠다. 그리고 이 모든 계산력이 결국 자연에서 왔다는 점도 개인적으로는 늘 인상깊다.