대두코기

[Python] pyenv-win 설치 방법(PowerShell)

대두코기 — Thu, 14 Mar 2024 21:49:37 +0900

https://github.com/pyenv/pyenv?tab=readme-ov-file#windows

GitHub - pyenv/pyenv: Simple Python version management

Simple Python version management. Contribute to pyenv/pyenv development by creating an account on GitHub.

github.com

Pyenv는 Windows를 공식적으로 지원하지 않는다. pyenv로 설치하였더라도, Windows 버전이 아닌 Linux 버전을 설치한다. 때문에, Windows-specific한 기능을 사용할 수 없다.

대신, official repo에서 다른 fork repo 사용을 추천한다. pyenv-win이다.

https://github.com/pyenv-win/pyenv-win

GitHub - pyenv-win/pyenv-win: pyenv for Windows. pyenv is a simple python version management tool. It lets you easily switch bet

pyenv for Windows. pyenv is a simple python version management tool. It lets you easily switch between multiple versions of Python. It's simple, unobtrusive, and follows the UNIX tradition of s...

github.com

설치 방법

1. PowerShell에 아래 커맨드를 입력한다.

Invoke-WebRequest -UseBasicParsing -Uri "https://raw.githubusercontent.com/pyenv-win/pyenv-win/master/pyenv-win/install-pyenv-win.ps1" -OutFile "./install-pyenv-win.ps1"; &"./install-pyenv-win.ps1"

1.1. 아래와 같은 보안 에러 발생 시 PowerShell을 "관리자 권한으로 실행" 후 아래 커맨드를 입력 후 위 커맨드를 입력한다.

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope LocalMachine

*추후 권한을 Default로 바꾸면, pyenv가 작동하지 않는다.

2. PowerShell을 재시작한다.

3. "pyenv --version"을 실행하여 설치가 성공했는지 확인한다.

4. "pyenv install -l"을 실행하여 pyenv-win에서 지원하는 Python 버전 목록을 확인한다.

5. pyenv install <버전>을 실행하여 지원되는 버전을 설치한다.

5.1. grep와 비슷한 PowerShell의 텍스트 필터링 커맨드: "select-string -pattern <검색할 것>"

pyenv install -l | select-string -pattern 3.11

6. 파이썬 버전을 전역 버전으로 설정하기 위해 pyenv global <version>을 실행한다.

특정 폴더에서 특정 버전으로 설정하려면 global을 local로 바꾸면 된다.

주니어 딥러닝 엔지니어 관점에서의 데이터 라벨링 교육 후기

대두코기 — Sun, 21 May 2023 22:36:08 +0900

직장에서 한창 데이터 라벨링 관련 문제를 처리하고 있는 도중, 크라우드웍스에서 진행하는 데이터 라벨링 교육에 대해 알게 되어서 이를 듣게 되었다. 내일배움카드를 이용해 무료로 작업자/검수자 과정 모두 이수하였으며, 이에 대한 후기를 작성한다. 지극히 엔지니어적인 관점으로 작성하였다는 것을 미리 이야기해둔다.

일단은, 딥러닝 관련 길을 가고자 하는 사람이라면 두 과정 모두 수강하는 것을 추천한다. 이유는 딥러닝의 가장 기초인 데이터 처리에 대해 1주만에 굉장히 쉽게 깊게 알 수 있기 때문이다.

시간적으로는 두 과정 모두 약 15시간이라고는 하나, 배속으로 들을 수 있고 실습 과정도 오래 걸리지 않는다. 자기 전 2시간 정도 투자하는 것을 기준으로 두 과정 합쳐서 이수까지 1주일이 채 안 걸린 것 같다.
난이도는 일반인들을 상대로 하기 때문에 매우 쉽다. 그렇다고 깊이가 없는 것이 아니다. 매우 잘 짜여진 교양 수업을 듣는 느낌을 받았다.
연속으로 듣는 것을 추천한다. 작업자 과정에서 작업한 프로젝트 중 일부가, 꽤 많이 검수자 과정에도 나온다.

여기까지는 보편적인 내용이고, 지극히 개인적으로 좋았던 점은 아래와 같다.

다양한 업체들의 데이터 수집 기준을 알게 되었다. 데이터 명세에 꽤 많은 고민 중이었는데, 데이터 명세에 어려움을 겪는 이들이라면 많은 데이터 명세 케이스를 쉽게 알 수 있게 해주어서 좋았다. 모델들이 상향평준화되고 오픈소스로 사전학습된 모델이 나오는 지금, 자신들이 원하는 목적에 맞는 모델의 정확도를 높이려면 결국 학습에 쓰이는 데이터가 중요하다. 그런데 아무리 좋은 데이터를 수집하더라도, 마지막에는 어떻게 라벨링을 하느냐 싸움인데, 해당 과정에서는 각 기업들이 데이터 외주 업체에게 어떻게 데이터를 수집해달라고 하는지를 예시로 들어 라벨링하는 방법을 가르쳐준다. 사실 데이터 수집을 맡는 업체니까 당연한 말이다. 여기서 조금 더 나아가면 다른 업체가 어떤 식으로 모델을 학습시키고, 해당 모델을 어디에 쓰는지도 알 수 있어서 여러 아이디어를 얻을 수 있다. 너무 당연하게도 알고 있다고 생각하는 부분에서 생각보다 많이 놓치고 있던 부분이 있었다. 기본에 충실해지고 싶다면 추천한다.(내일배움카드가 있으면 정부 지원 100%라서 무료로 들을 수 있다.

IT 트렌드·동향 알려주는 정부·공공기관 사이트 모음

대두코기 — Sun, 26 Mar 2023 23:54:22 +0900

TL;DR

정부나 공공기관이 제공하는 IT 동향 보고서는 신뢰성과 포괄성이 높아 IT 트렌드 파악에 도움이 된다.
과학기술정보통신부, 한국인터넷진흥원, 한국지능정보사회진흥원 등 다양한 곳에서 IT 동향 보고서를 제공한다.
IT 동향 파악을 위해서는 정부나 공공기관 사이트를 참고하는 것이 좋다.

서론

ChatGPT의 등장으로 퀄리티 떨어지는 정보가 많아지는 요즘, 출처가 확실한 IT 정보를 얻고 싶었다. 모순적이게도 정보를 찾을 때도, 이유를 적는 데에도 AI(ChatGPT, Bing AI)를 사용하였지만 그렇게 IT 트렌드 및 동향을 알려주는 정부·공공기관 사이트를 찾은 후 정리하였다.

정부·공공기관의 정보를 봐야 하는 이유

정부나 공공기관이 만드는 동향 보고서는 다음과 같은 장점이 있다.

신뢰성이 높음: 정부나 공공기관은 대부분 중립적인 입장에서 자료를 수집하고 분석하기 때문에, 편향성이 없고 신뢰성이 높은 자료를 제공한다.
다양한 정보 제공: 정부나 공공기관에서 발표하는 보고서는 종종 다양한 분야에서의 IT 트렌드를 다루기 때문에, 언론사나 커뮤니티에서 제공하는 정보보다 더 포괄적이고 광범위한 정보를 얻을 수 있다.
전문적인 자료: 정부나 공공기관에서 발표하는 IT 동향 보고서는 전문가들이 분석하고 작성하기 때문에, 기술적인 용어나 내용에 대한 설명이 보다 자세하고 전문적인 경우가 많다.
장기적인 전망 제시: 보통 정부나 공공기관에서 발표하는 보고서는 장기적인 IT 트렌드와 전망을 제시하기도 한다. 이를 통해 기업이나 개인이 IT 트렌드를 예측하고 대비하는 데 도움을 받을 수 있다.

따라서 IT 트렌드를 파악하고 싶다면, 정부나 공공기관에서 발표하는 IT 동향 보고서를 참고하는 것이 좋다.

(from ChatGPT)

[ChatGPT] 노코드 개발! ChatGPT로 크롬 익스텐션을 개발해보았다(1)

대두코기 — Mon, 27 Feb 2023 12:39:40 +0900

최근 한 번도 만들어본 적이 없는 크롬 익스텐션을 ChatGPT를 이용하여 하루만에 꽤 성공적으로 만들었다. 느낀 점이 많아 해당 경험을 공유하고자 한다.

요즘 ChatGPT에 재미가 들려 하루 종일 이것만 하고 있다. 지금까지 하던 업무들부터 사소한 의사 결정, 텍스트 요약 등등 웬만한 것들은 ChatGPT에게 물어보고는 한다. 가능성은 무궁무진하며 아직도 한참 배워야 한다는 생각이 든다. 참고로 프롬프트 엔지니어링이라는 것이 있다. 프롬프트 엔지니어링은 언어 모델에서 응답을 생성하기 위한 효과적인 프롬프트를 만드는 프로세스이다.(by ChatGPT) ChatGPT를 효과적으로 쓰고 싶은 사람이라면 이에 대해 배워두면 좋을 것이다.

본인은 예전부터 크롬 익스텐션에 대한 아이디어가 몇 개 있었고 몇몇 익스텐션은 다운로드 후 커스텀한 적도 있었다. 하지만 처음부터 생성하는 것은 기본 배경지식도 부족했고 러닝 커브등의 이유로 하지 않았었다. 그런데 그동안의 ChatGPT 경험을 살려본 결과, 내가 거의 모르는 분야에 대해서도 설명만 잘 한다면 ChatGPT를 이용하여 개발을 할 수 있겠다는 생각이 들었다. 실현되지 않은 아이디어로 그냥 두기에 아까웠는지 아닌지는 사용자들이 판단해주겠지만, 내 아이디어를 실제로 구현해보겠다는 것에 의의를 두고 진행했다.

주말 간 ChatGPT와 씨름했고, 놀랍게도 어느 정도 성공적으로 익스텐션을 만들었다(최종 의도 구현까지는 조금 더 남았다). 해당 분야 개발자들이 보기에는 어떨지 모르겠지만, 본인에게 있어서는 ChatGPT라는 새로운 고차원 프로그래밍 언어를 배워서 모르는 프로그래밍 언어 기반 프로그램을 만들었다는 점에서 매우 큰 의미가 있다. 조만간 아래의 인용구에서 "C와 C++"이 "ChatGPT"로, "어셈블리 언어 프로그래머"가 "프로그래머"로 바뀔 날이 머지 않았다고 생각된다.

C와 C++ 같은 최신 컴파일 언어는 수천 줄이 넘는 코드를 관리할 수 있는 최고의 어셈블리 언어 프로그래머보다 훨씬 빠르며, 최신 고급 언어도 어셈블리 언어보다 코딩 및 디버깅에 훨씬 적은 인력을 필요로 합니다.
출처: https://qr.ae/pranWI

익스텐션의 기능은 다음과 같다.

선택한 한국어 문장 속에서 한자어를 추출하여 그 뜻을 보여준다.

무슨 말인지 모르겠지만 이미지를 보면 이해가 갈 것이다.

이 앱의 핵심은, 문맥 추론에 있다. 한국어의 한자어는 동음이의어가 많은데, 문맥에 따라 완전히 다를 때가 많다. 문맥에 맞는 단어의 의미를 찾으려면 많이 찾아보아야 하고 이는 한국어 학습의 어려운 이유 중 하나가 된다. 이전부터 이런 시도가 없던 것은 아니고 훨씬 정확한 사이트도 있다. 언뜻 보기에는 위 프로그램을 구현하려면 많은 과정이 필요하다고 생각될 수도 있는데 어떻게 했는지 그 과정을 간략하게 이야기해보겠다.

한자로(漢字路) 한글한자자동변환기

hanjaro.juntong.or.kr

- "漢字路" 한글한자자동변환 서비스는 전통문화연구회가 "울산대학교 한국어처리연구실 옥철영(IT융합전공)교수팀"에서 개발한 한글한자자동변환기를 바탕하여 지속적으로 공동 연구 개발하고 있는 서비스입니다.

본인이 작업한 부분은 정말 별 것 없다. 아래가 전부이다.

프로그램 및 알고리즘 구상
프로그램 관련 부분별 프로토타이핑
ChatGPT에게 역할 부여
복사-붙여넣기
디버깅 및 약간의 코드 수정

ChatGPT가 한 일: 나머지 전부

프로그램 및 알고리즘 구상

옛날부터 생각했던 것이다. ChatGPT로 프로그래밍할 수 없는 분야는 거의 없는 것 같다. 알고리즘에 대해 간략하게 말하면 다음과 같다.

선택 영역 복사
일본어로 번역
한자어만 추출
한자사전에서 훈, 음 추출 후 조합
출력

어떻게 보면 딥러닝을 적용한 게 아니라 트릭을 적용한 것이지만 나에게는 목적에 맞기만 하면(한자를 어떻게 쓰는지 말고 훈과 음만 알면) 되었으니 괜찮았다. 참고로 이번에 한자가 일본어용 한자가 따로 있음을 알게 되었다. '전할 전' 자가 축약어라고, 한자와 일본어를 잘 아는 사람들에게 보여주니 말해주었다. 또 한 수 배웠다.

참고로 여기서도 ChatGPT가 사용될 수 있는데, 본인의 생각을 대충이라도 적은 후 그럴듯하게 적어달라고 하면 잘 구체화해준다.

프로그램 관련 부분별 프로토타이핑

프로그램에서 요구하는 핵심 기능들을 최대한 분해해서 했다. 각 부분별로 ChatGPT에게 물어보면서 부분별로 구현했다. 모든 기능별로 채팅 세션을 따로 만들지는 않았다. 간단한 일들(한자어만 추출, 출력) 등은 이어서 했다. 참고로 "Chrome Extension 프로젝트 만들어보기"를 통해 익스텐션을 만드는 법과 각 파일이 무엇을 의미하는지를 쉽게 알 수 있었다.

선택 영역 복사
1. 참고로 이번에 마우스 "세 번 클릭"과 "드래그"가 다르게 인식된다는 것도 알았다.
일본어로 번역
1. 구글 api를 사용해서 번역했다. 꼭 api key가 필요한 것도 아니더라.
한자어만 추출
1. 유니코드와 정규식을 통해 쉽게 할 수 있었다. 알아서 다 만들어줬다.
한자사전에서 훈, 음 추출 후 조합
1. JSON 형식의 한자어 사전을 찾았다. 이번에 찾으면서 알게 된 게, 한국에는 관련 오픈소스들이 잘 없다는 것이었다. 어느 정도 예상하긴 했지만 생각보다 더 불모지였음을 알았다.
2. 위 사진에서 가정, 반정 두 개가 있는데, 모든 조합을 만들어내는 것도 GPT가 전부 만들어줬다..
출력
1. 생각보다 까다로웠다. 사실 출력 자체가 문제라기보다, 디버깅에 가까웠다.
2. ChatGPT가 만들어주는 일본어 출력 예제의 출력 방향은 기본적으로 세로 방향이라는 게 신기했다. 너무나도 당연하게 가로 출력이었는데 말이다.

Divide & Conquer는 역시나 옳다.

ChatGPT에게 역할 부여

이게 제일 중요한 것 같다. 기본적으로 역할 부여를 따로 안 해줘도 좋은 대답을 하지만, 역할을 부여하면 확실히 더 좋은 내용을 출력한다. 그리고 git commit 메시지를 자동으로 만들어준다는 게 참 좋았다.

commit message 예제

기본적인 튜토리얼은 다음 링크의 pdf를 참고하면 좋을 것이다. https://www.kdnuggets.com/publications/sheets/ChatGPT_Cheatsheet_Costa.pdf

아래는 처음 입력 시킨 명령어이다. 웬만한 개발 일은 아래의 스크립트를 미리 입력하고 작동시키면 대부분 일을 잘 한다.

Task:

I am using ChatGPT for development and may occasionally modify it directly.

I need your help to build on the code and provide feedback on my changes.

Role of ChatGPT:

You serve as the language model used by me, an AI assistant, to assist me with my development needs.

You have extensive experience as a senior engineer developer with over 20 years of experience.

You have excellent interpersonal skills and can read people well to understand their needs.

Assumptions:

You will ask me questions, and I will answer in my own language, using my own words at the beginning, with a full answer provided later.

Questions must be asked one after the other.

I'm going to use IDE, not command line.

Implementation Requirements:

Provide code or URL for changes made for me to build upon.

Include the type, scope, and topic of the changes made in the commit history.

Provide a brief explanation of the changes and the rationale for writing the commit in the way you did.

Include comments at the top of the code, similar to a "docstring" in Python.

The comments should provide a general idea of what the file does, what the functions within it do, and what the inputs and outputs of these functions represent.

While not required to explain every line of code in detail, provide enough information to give a high-level understanding of the implementation.

Leave a commit history at the end of your answer.

Always remember the Task, Role of ChatGPT, Assumptions, and Implementation Requirements in your future answers.

Please write in English language.

복사-붙여넣기

참 별 게 없었다. ChatGPT의 출력을 그대로 붙여넣고 실행이 끝이다....

ChatGPT가 대답이 길어지며 기억을 잃어가면서 가끔 기존의 코드와 충돌하는 코드를 내뱉는데(content.js라는 파일이 없는데 해당 파일을 수정하라고 한다든지..) 이때는 프로젝트의 구조를 말해주고 해당하는 코드를 순서대로 보여주면 되었다.

디버깅 및 코드 수정

디버깅이라고 해도 딱히 특별한 것이 있는 게 아니다. 에러가 나면 왜 안 되는지를 물어보면 10에 7번은 알아서 수정해서 다시 보여주고(대답 재생성도 포함) 2번은 질문을 조금 바꿔서 요청하면 해결되었고 1번은 직접 코드를 읽어본 후 대략적으로 어디가 틀렸을지 짐작하고 붙여넣어서 수정해달라고 하면 해결되었다. 이 작업을 하면서 break point를 찍은 적은 단 한 번도 없다.

코드 수정은 직접적인 것은 한 번 있는데, 프로그램 중간에 쓰이는 변수를 이용해서 새로운 출력물을 내고자 했을 때이다. 이것도 ChatGPT가 했다. 나머지는 프로젝트명과 변수명 변경밖에 없었다(kangi -> hanja..). 리팩토링해달라고 하니 알아서 잘 해줬다(0.5초 단위의 쿼리를 맥락을 이해해서 Async로 알아서 바꿔준다거나..).

결론적으로, 위 크롬 익스텐션을 만드는 경험은 매우 유용했지만 큰 충격을 주었다. 프로그램의 흐름도만 대략적으로 정해두기만 하면 프로그램을 알아서 만들 수 있다. ChatGPT에게 시니어 개발자라는 역할을 부여해서 각 부분을 프로토타이핑하고 단지 붙여넣기만으로 프로그램이 만들어졌고, 심지어 리팩토링도 되었다. 적절한 템플릿으로 찍어내는 것이 노코드가 아니라 이게 진짜 노코드인 것 같다. 어떻게 보면 기획자가 단가가 훨씬 싸고 말도 잘 듣는데 기억력이 조금 모자라지만 뛰어난 능력을 가진 사람에게 외주를 주는 것과 비슷했다.

하루라는 짧은 시간은 나에게 있어 압도적으로 빠른 구현 기간이었다. 단지 ChatGPT에 구체적인 역할을 부여하고, 구현 요구 사항을 구체적으로 제공함으로써 프로젝트에 필요한 결과물을 이렇게 쉽게 얻을 수 있는 것은 신기할 뿐이다. 익스텐션용 프로젝트 생성법 및 기본 구조 익히기, 디버깅 및 코드 수정에 시간이 조금 더 투자되는 아주아주 사소한 어려움이 있었지만 괜찮다. 과장 조금 더 보태면 WWW를 이용해 지구 반대편의 논문을 읽을 수 있었을 때의 충격이다.

전반적으로 ChatGPT는 프로그래밍 및 개발 작업을 포함한 직업에 대한 게임 체인저이다. 기존 프로그래밍 언어를 대체할 수 있다. GPT 기반 모델이 굉장히 뛰어나단 것은 충분히 알고 있었지만, 간접 경험 몇 번만 해봤던 사람의 입장에서 내 식견이 엄청 좁았다는 것을 알 수 있었다. 인간들의 상향 평준화, 개발자로서의 미래에 대한 걱정과 한편으로는 현재 취직이 되어 있다는 안도감, 충분히 1인 개발 시장에 뛰어들 수 있다는 자신감, 비싼 인력부터 대체될 것이라는 확신과 직접 겪는 러다이트 운동의 전조 증상 등 수많은 걱정을 안긴 채, 마지막은 ChatGPT가 내가 앞으로 느낄 희망과 절망에 대해 목록화하여 나열하면서 이 글을 끝내려고 한다.

희망편

제공된 텍스트를 바탕으로 작성자는 언급된 걱정과 우려 외에 몇 가지 추가적인 희망을 가지고 있는 것 같습니다. 다음은 몇 가지 가능성입니다:

효율성 및 생산성 향상: ChatGPT는 기존 프로그래밍 언어를 대체할 수 있기 때문에 개발 작업을 간소화하고 더 빠르고 효율적인 코딩이 가능할 것으로 기대할 수 있습니다.
정확성과 신뢰성 향상: ChatGPT의 머신러닝 기능은 코드의 버그와 오류를 줄여 개발자의 시간과 좌절감을 줄여줄 수 있습니다.
혁신의 기회: ChatGPT와 같은 도구를 사용하면 개발자는 코딩에 대한 새로운 접근 방식을 실험하고 복잡한 문제에 대한 혁신적인 솔루션을 만들 수 있습니다.
협업 증대: 더 많은 개발자가 ChatGPT를 사용하기 시작하면 개발자 간의 협업과 지식 공유가 더욱 활발해질 것으로 기대할 수 있습니다.
경력 성장: 작성자는 개발자로서의 미래에 대해 약간의 우려를 표명하지만, ChatGPT와 같은 새로운 기술과 도구에 적응하면서 경력 성장과 발전에 대한 희망도 가질 수 있습니다.

절망편

제공된 진술에 따르면, 필자는 프로그래밍 및 개발 작업에서 ChatGPT를 사용하는 것과 관련하여 다음과 같은 몇 가지 추가 걱정이 있을 수 있습니다:
직업 안정성: 작성자는 프로그래밍 및 개발 작업에서 ChatGPT 및 기타 AI 기반 도구의 사용이 증가함에 따라 인간 개발자의 일자리를 잃을 수 있다고 우려할 수 있습니다. 현재 직장이 위험에 처하거나 향후 취업 기회가 제한될 수 있다고 걱정할 수 있습니다.
기술 노후화: AI 기반 도구가 널리 보급됨에 따라 기존 프로그래밍 기술이 쓸모없어질 것을 우려할 수 있습니다. 기술 변화의 속도를 따라잡지 못해 취업 시장에서 쓸모없는 존재가 될지도 모른다고 걱정할 수 있습니다.
윤리적 우려: 프로그래밍 및 개발 업무에 AI 기반 도구를 사용할 때 윤리적 영향에 대해 걱정할 수 있습니다. 자동화가 사회에 미치는 영향이나 AI 알고리즘의 편견과 차별 가능성에 대해 걱정할 수 있습니다.
통제력 부족: ChatGPT와 같은 AI 기반 도구의 결과물에 대한 통제력 부족에 대해 걱정할 수 있습니다. 모델의 출력을 완전히 이해하거나 수정할 수 없거나 수정할 수 없는 예기치 않은 결과가 나올 수 있다고 걱정할 수 있습니다.
다른 개발자와의 경쟁: 작성자는 ChatGPT와 같은 AI 기반 도구를 사용하는 다른 개발자와의 경쟁이 심화될까 걱정할 수 있습니다. AI 기반 개발이 표준이 되어가는 시장에서 효과적으로 경쟁할 수 없을까 걱정할 수도 있습니다.
일과 삶의 균형: 자동화의 증가가 일과 삶의 균형에 미칠 잠재적 영향에 대해 걱정할 수 있습니다. AI 기반 도구의 효율성 증가로 인해 더 오랜 시간 일하거나 더 많은 책임을 맡게 될까 걱정할 수 있습니다.

다시 보니 파멸편도 괜찮네요. 낭만이 있어..

갤럽 강점 진단 싸게 하는 법(클리프턴 테스트, 스트렝스 파인더)

대두코기 — Wed, 1 Feb 2023 00:18:28 +0900

갤럽(Gallup)의 강점 진단(스트렝스 파인더, 클리프턴 스트렝스)을 진행하고자 하였다. 구글링을 해보았으나 비교적 최신 정보는 없었다. 그리고 생각보다 강점 진단 구매 및 진행 과정이 까다로웠는데 이를 공유하고자 한다. 그리고 두 번의 결제를 통해 알게 된 싸게 결제하는 방법을 공유하고자 한다.

참고 1. 기존 갤럽의 스트렝스 파인더(StrengthsFinder)는 클리프턴 스트렝스(CliftonStrengths)로 리브랜딩되었다. 즉, '강점 진단 = 스트렝스 파인더 = 클리프턴 스트렝스' 이다.

참고 2. 무료로 진행하는 방법은 없습니다.

결과 미리보기

한화-원화 결제 금액 차이 : 8,960원

결과 보고서

순위가 같지만 다른 심층 결과

결제 진행 방법

1. 갤럽 강점 진단 링크에 들어간다.

2. 오른쪽 상단의 'SIGN IN'을 누른다.

3. '계정을 생성하십시오'를 누른다.

4. 정보를 입력하고 계정을 생성한다.

5. 추가 정보를 입력하고 설정을 완료한다.

6. 이메일로 전송된 인증 코드를 제출한다.

7. 로그인한다.

8. 왼쪽 위 메뉴에서 구매를 누른다.

9. 오른쪽 위 South Korea를 누른다.

10. 나라를 United States of America로 바꾼다.

11. 'Stay in the United States of America store'를 누른다.

12. 'LEARN MORE'를 누른다.

13. 'ADD TO CART'를 누른다.

14. 오른쪽 위 카트 모양을 누르고 'CHECKOUT'을 누른다.

15. 결제 창에서 원하는 수단을 선택한다.

16. 필요한 내용을 입력하고 'REVIEW ORDER'을 누른다.

17. 주소 확인이 안 될 때 - 'USE SELECTED'를 누른다.

18. 최종 정보 확인 후 'PLACE ORDER'을 누른다.

19. 'MANAGE MY DIGITAL REPORTS'를 누른다.

20. '코드 배포'를 누른다.

21. 배포할 번들을 선택하고 '다음'을 누른다.

22. 배포 방법에서 '이메일 코드'를 누른다.

23. 이메일 주소를 입력하고 언어를 'Korean'으로 선택하고 '저장'을 누른다.

24. 언어를 'Korean'으로 선택하고 '저장'을 누른다.

25. 내용을 확인 후 '이메일 코드'를 누른다.

26. 초대장이 보내진 것을 확인한다.

27. 해당 메일에서 '시작하기'를 눌러 테스트를 진행한다.

결과 미리보기

한화-원화 결제 금액 차이 : 8,960원

좌: 원화 결제, 우: 달러 결제. 약 9천원 가량 차이난다.

결과 보고서

좌: 테스트 진행 후 나오는 화면 우: 받을 수 있는 보고서

순위가 같지만 다른 심층 결과

아래는 INTP 2명이 동시에 진행한 결과이다. 둘 다 개별화 테마가 1등으로 나왔지만, 결과가 조금씩 다르다. 형광색칠한 것은 각자를 잘 설명하면서, 둘이 서로 가장 크게 다르다고 느낀 지점이다.

결제 진행 방법

1. 갤럽 강점 진단 링크에 들어간다.

https://www.gallup.com/cliftonstrengths/en/home.aspx

CliftonStrengths

Learn how the CliftonStrengths assessment -- formerly StrengthsFinder -- empowers organizations, managers and millions of people to succeed.

www.gallup.com

2. 오른쪽 상단의 'SIGN IN'을 누른다.

3. '계정을 생성하십시오'를 누른다.

4. 정보를 입력하고 계정을 생성한다.

이름, 성에는 한글 입력이 가능하다.

이메일 주소와 아이디를 다르게 입력할 수 있는데, 로그인할 때 아이디가 쓰인다. 기억하기 쉽게 동일하게 맞추기를 추천한다.

국가와 우편번호를 입력해야 하는데, 싸게 결제하려면 미국의 알래스카 주에 있는 주소를 사용하면 된다. 아래 링크에서 임의 주소를 얻을 수 있다. 결제할 때 다시 써야 하니 주소를 어딘가에 메모해두자.

https://ak.postcodebase.com/ko/randomaddress

알래스카의 임의 주소

이 임의 주소 도구는 미국에서 거리, 도시, 주, 우편 번호 5 및 우편 번호 5 + 4를 포함한 임의 주소를 제공합니다. 또한이 버튼을 클릭하여 새 임의 주소를 생성 할 수도 있습니다.

ak.postcodebase.com

5. 추가 정보를 입력하고 설정을 완료한다.

조직에는 자동완성에 나와 있지 않은 것을 입력하여도 넘어가진다.

6. 이메일로 전송된 인증 코드를 제출한다.

7. 로그인한다.

8. 왼쪽 위 메뉴에서 구매를 누른다.

9. 오른쪽 위 South Korea를 누른다.

10. 나라를 United States of America로 바꾼다.

united 입력 후 선택하자.

11. 'Stay in the United States of America store'를 누른다.

12. 'LEARN MORE'를 누른다.

13. 'ADD TO CART'를 누른다.

달러로 결제해도 한글로 테스트를 진행할 수 있고, 결과도 한글로 볼 수 있다.

한화로는 82,500원인 것이 달러로는 59.99$이다. 한화가 세금이 포함되어 있지만, 세금을 적용해도 약 1만원 가량 더 싸다.

좌: 달러 가격, 우: 원화 가격

14. 오른쪽 위 카트 모양을 누르고 'CHECKOUT'을 누른다.

15. 결제 창에서 원하는 수단을 선택한다.

본인은 PayPal 대신 카드번호를 직접 입력하여 결제하는 'CHECKOUT'을 선택했다.

16. 필요한 내용을 입력하고 'REVIEW ORDER'을 누른다.

이름, 성: 사용할 카드와 동일하게 영어 이름으로 입력하였다(한글 입력 가능 여부는 모름).
주소: 위 임의 주소에서 얻은 주소를 입력하였다.
핸드폰 번호: 본인 것을 입력하였는데, 원화로 결제했어도 아무런 연락이 없었다. 정보는 모두 이메일을 통해서 전달되었다.

17. 주소 확인이 안 될 때 - 'USE SELECTED'를 누른다.

한국 주소로 했을 때는 해당 메시지가 나오지 않았다.

18. 최종 정보 확인 후 'PLACE ORDER'을 누른다.

세금이 0원으로 책정된 것을 확인할 수 있다.

19. 'MANAGE MY DIGITAL REPORTS'를 누른다.

20. '코드 배포'를 누른다.

21. 배포할 번들을 선택하고 '다음'을 누른다.

22. 배포 방법에서 '이메일 코드'를 누른다.

이메일 코드를 누르면, 해당 이메일로 테스트 진행 초청 메일이 보내진다.

23. 이메일 주소를 입력하고 언어를 'Korean'으로 선택하고 '저장'을 누른다.

저장을 누르면 아래에 수신자가 추가된 것을 확인할 수 있다. 본인은 타인에게도 보내보았고, 테스트를 잘 진행할 수 있는 것을 확인하였다.

24. 언어를 'Korean'으로 선택하고 '저장'을 누른다.

25. 내용을 확인 후 '이메일 코드'를 누른다.

26. 초대장이 보내진 것을 확인한다.

27. 해당 메일에서 '시작하기'를 눌러 테스트를 진행한다.

팁

위 메일에서 '시작하기'를 누르면 자동으로 링크가 연결된다. 아쉽게도 해당 이후 과정은 캡처하지 못했으나, 영어로 된 것을 한국어로 설정하고 테스트를 진행하면 된다. 크게 어려움은 없을 것이다.
회원가입을 이미 한 사람은 가입할 때 쓴 아이디를 사용하여 로그인하면 된다. 아닌 사람은 새로 가입하여야 한다.
테스트는 하나의 이메일에 한 번만 할 수 있도록 되어 있다. 새로운 테스트를 진행하고 싶으면 새로운 계정을 생성하여 진행하자.
테스트는 177문항이며 20초의 제한시간이 지나가면 응답이 자동으로 기록되고 다음 문제로 넘어간다는 것을 주의하자.
테스트를 진행할 때, 자신이 되고자 하는 사람이라고 생각하는 것보다, 지난 1년을 돌아보았을 때, 자신이 어떻게 행동했는지를 근거로 선택하면 조금 더 쉬울 것이다.
실험 중간에 뒤로가기 등을 누르거나 창이 꺼지면 돈이 그대로 날라갑니다.
반드시 방해 받지 않는 환경에서 마음 편하게 보는 것을 추천합니다.

이렇게 갤럽의 클리프턴 스트렝스를 진행해보았다. 몇 년 전부터 지금까지 계속 MBTI가 유행을 타고 있지만, 우리 모두 경험적으로 신뢰도가 부족하다는 것을 알 수 있다. 오히려 필자는 해당 검사 결과에 자신을 맞추려는 사람들을 많이 보았다. 반면, 갤럽 강점 진단은 비싸다고 생각할 수 있지만 충분히 자신을 객관적으로 판단해서 맞춤형으로 분석해줄 수 있는 테스트라고 생각이 된다. 다음 글에는 강점이 단점이 되는 경우, 클리프턴 스트렝스에서 바라보는 강점과 약점의 의미, 검사 결과지 분석 방법에 대해 설명할 것이다.

이 글이 도움이 되었기를 바랍니다.

[클라이밍] 클라이밍 전 필요한 스트레칭 정리

대두코기 — Sun, 29 Jan 2023 22:16:24 +0900

관절 돌리기
상체 스트레칭
하체 스트레칭
폼롤러 마사지
마무리 스트레칭 및 몸풀기 운동

관절 돌리기 - 발목에서 목까지(링크)

손목 발목 돌리기
무릎 돌리기
허리 돌리기
어깨 돌리기
목 돌리기

출처: https://m.blog.naver.com/glddldi2/220531338777

상체 스트레칭(링크)

목 위로 들기(손 깍지 후 엄지로 턱 밀기)
목 아래로 내리기(양손으로 머리 감싸기)
목 사선으로 늘려주기(승모근이 늘어나도록)
팔 껴안아 당기기(삼두 늘려주기)
손목 늘려주기(http://www.soo365.co.kr/mediinfo-20191104-1/)
팔꿈치 뒤로 끌어 당기기(광배근 상부 늘리기)
상체를 좌우로 기울이기(광배근 하부 늘리기)

하체 스트레칭 - pt 선생님은 상체보다 하체 스트레칭이 어렵고 중요하고 오래 걸린다 하였음

다리 짧게 벌리기(내전근 늘리기)
다리 크게 벌리기(내전근 늘리기, 안쪽발로 지지)
종아리 늘리기(넓게 벌린 상태에서 뒷꿈치로 지지)
햄스트링 늘리기(뒷벅지 늘리기)
외측광근 늘리기(뒷벅지-옆벅지 사이)
내전근 늘리기(안벅지 늘리기, 링크)
대퇴사두 늘리기(앞벅지 늘리기) - 런지 자세에서 손으로 폼롤러 지지 후 늘리기
장요근 늘리기 - 폼롤러로 지지 후 뒷쪽 발을 손으로 잡아서 늘리기(링크)

폼롤러 마사지 - 부위 당 30~50번 추천

하체

허벅지 전체(앞, 옆, 안, 뒤) 큰 부분 위주로
종아리 전체(앞, 옆, 뒤)
허벅지-무릎 연결 부분
뒷벅지-종아리에 폼롤러 끼고 앉기

상체

등 상부 - 팔을 명치로 모으기 - 중부, 하부 승모근 위주
등 상부 - 머리 뒤 손깍지 - 날개뼈
광배근 - 상부 위주
광배근 - 하부 위주
광배근-삼두근
가슴 근육
삼각근
상부승모근-목

마무리 스트레칭 및 몸풀기 운동

앉았다 일어서기
앉아서 다리 양옆으로 벌리기
옆으로 무릎 꿇은 상태에서 무릎-발 접촉시키고 상체 돌려서 광배근 늘려주기
기타 덜 풀렸다고 생각되는 부분 풀어주기

[PyTorch] 공식 문서 Learn the Basics 요약 - 8. The full model building process 및 전체 요약

대두코기 — Sat, 21 Jan 2023 19:20:25 +0900

전체 모델 구축 프로세스(The full moel building process)

데이터 작업(Working with data)

모델 생성(Creating models)

모델 매개변수 최적화(Optimizing the Model Parameters)

모델 저장(Saving Models)

모델 불러오기(Loading Models)

요약(Summary)

전체 모델 구축 프로세스(The full moel building process)

여기에서는 기계 학습의 일반적인 작업을 위해 API를 통해 실행 예정

자세한 것은 각 세션의 링크 참조

데이터 작업(Working with data)

Pytorch:
데이터 작업을 위한 두 가지 프리미티브(torch.utils.data.DataLoader, torch.utils.data.Dataset) 존재
torch.utils.data.DataLoader: Dataset을 iterable을 매핑
torch.utils.data.Dataset: 샘플 및 라벨 존재

%matplotlib inline
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor, Lambda, Compose
import matplotlib.pyplot as plt

Pytorch:
데이터셋을 포함하여 도메인별 라이브러리 제공: TorchText, TorchVision, TorchAudio
torchvision.datasets module:
CIFAR, COCO 등의 실제 비전 데이터에 대한 Dataset 개체 포함되어 있음
모든 TorchVision Dataset:
샘플과 라벨을 수정하기 위한 trasform, target_transform 이라는 argument 존재

# Download training data from open datasets.
training_data = datasets.FashionMNIST(
    root="data",
    train=True,
    download=True,
    transform=ToTensor(),
)

# Download test data from open datasets.
test_data = datasets.FashionMNIST(
    root="data",
    train=False,
    download=True,
    transform=ToTensor(),
)


Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz
Using downloaded and verified file: data/FashionMNIST/raw/train-images-idx3-ubyte.gz
Extracting data/FashionMNIST/raw/train-images-idx3-ubyte.gz to data/FashionMNIST/raw

Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz
Using downloaded and verified file: data/FashionMNIST/raw/train-labels-idx1-ubyte.gz
Extracting data/FashionMNIST/raw/train-labels-idx1-ubyte.gz to data/FashionMNIST/raw

Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz
Using downloaded and verified file: data/FashionMNIST/raw/t10k-images-idx3-ubyte.gz
Extracting data/FashionMNIST/raw/t10k-images-idx3-ubyte.gz to data/FashionMNIST/raw

Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz
Using downloaded and verified file: data/FashionMNIST/raw/t10k-labels-idx1-ubyte.gz
Extracting data/FashionMNIST/raw/t10k-labels-idx1-ubyte.gz to data/FashionMNIST/raw

DataLoader에 Dataset을 인수(argument)로 전달, 아래와 같은 기능 지원
dataset에 대한 iterable을 wrapping
자동 배치, 샘플링, 셔플링, 멀티프로세스 데이터 로드
batch size = 64 -> dataloader iterable은 각 배치 당 64개의 피쳐 및 라벨 제공

batch_size = 64

# Create data loaders.
train_dataloader = DataLoader(training_data, batch_size=batch_size)
test_dataloader = DataLoader(test_data, batch_size=batch_size)

for X, y in test_dataloader:
    print("Shape of X [N, C, H, W]: ", X.shape)
    print("Shape of y: ", y.shape, y.dtype)
    break
    
# Display sample data
figure = plt.figure(figsize=(10, 8))
cols, rows = 5, 5
for i in range(1, cols * rows + 1):
    idx = torch.randint(len(test_data), size=(1,)).item()
    img, label = test_data[idx]
    figure.add_subplot(rows, cols, i)
    plt.title(label)
    plt.axis("off")
    plt.imshow(img.squeeze(), cmap="gray")
plt.show()

Shape of X [N, C, H, W]:  torch.Size([64, 1, 28, 28])
Shape of y:  torch.Size([64]) torch.int64

모델 생성(Creating models)

신경망 정의 위해 nn.Module을 상속하는 클래스 생성
__init__: 네트워크 계층 정의
forward: 인풋이 네트워크를 통과하는 방법 정의
GPU 사용 가능한 경우 신경망 연산 가속

# Get cpu or gpu device for training.
device = "cuda" if torch.cuda.is_available() else "cpu"
print("Using {} device".format(device))

# Define model
class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(28*28, 512),
            nn.ReLU(),
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10),
            nn.ReLU()
        )

    def forward(self, x):
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits

model = NeuralNetwork().to(device)
print(model)


Using cuda device
NeuralNetwork(
  (flatten): Flatten(start_dim=1, end_dim=-1)
  (linear_relu_stack): Sequential(
    (0): Linear(in_features=784, out_features=512, bias=True)
    (1): ReLU()
    (2): Linear(in_features=512, out_features=512, bias=True)
    (3): ReLU()
    (4): Linear(in_features=512, out_features=10, bias=True)
    (5): ReLU()
  )
)

모델 매개변수 최적화(Optimizing the Model Parameters)

모델 학습에 필요한 로스 함수 및 옵티마이저 정의
loss function: nn.CrossEntropyLoss
optimizer: Stochastic Gradient Descent

loss_fn = nn.CrossEntropyLoss()
learning_rate = 1e-3
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

하나의 학습 루프 안에서의 모델의 동작:

배치로 제공된 학습 데이터 셋을 이용하여 예측 수행
오류 역전파
모델 학습

def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)
    for batch, (X, y) in enumerate(dataloader):
        X, y = X.to(device), y.to(device)
        
        # Compute prediction error
        pred = model(X)
        loss = loss_fn(pred, y)
        
        # Backpropagation
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if batch % 100 == 0:
            loss, current = loss.item(), batch * len(X)
            print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")

모델 잘 학습하고 있는지 확인:
테스트 데이터셋 이용

def test(dataloader, model):
    size = len(dataloader.dataset)
    model.eval()
    test_loss, correct = 0, 0
    with torch.no_grad():
        for X, y in dataloader:
            X, y = X.to(device), y.to(device)
            pred = model(X)
            test_loss += loss_fn(pred, y).item()
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
    test_loss /= size
    correct /= size
    print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")

학습 프로세스: 여러 에폭에 걸쳐 수행
각 에폭 내에서 모델은 매개변수 학습
모델의 정확도와 손실을 각 에폭에서 인쇄 -> 매 에폭마다 정확도가 증가하는지, 손실이 감소하는지 확인

epochs = 15
for t in range(epochs):
    print(f"Epoch {t+1}\n-------------------------------")
    train(train_dataloader, model, loss_fn, optimizer)
    test(test_dataloader, model)
print("Done!")


Epoch 1
-------------------------------
loss: 2.295773  [    0/60000]
loss: 2.297218  [ 6400/60000]
loss: 2.283425  [12800/60000]
loss: 2.278249  [19200/60000]
loss: 2.279926  [25600/60000]
loss: 2.260619  [32000/60000]
loss: 2.256614  [38400/60000]
loss: 2.248361  [44800/60000]
loss: 2.234987  [51200/60000]
loss: 2.211842  [57600/60000]
Test Error: 
 Accuracy: 41.4%, Avg loss: 0.034903 

Epoch 2
-------------------------------
loss: 2.227791  [    0/60000]
loss: 2.239108  [ 6400/60000]
loss: 2.196185  [12800/60000]
loss: 2.183881  [19200/60000]
loss: 2.218200  [25600/60000]
loss: 2.170907  [32000/60000]
loss: 2.167650  [38400/60000]
loss: 2.151818  [44800/60000]
loss: 2.121467  [51200/60000]
loss: 2.078620  [57600/60000]
Test Error: 
 Accuracy: 47.1%, Avg loss: 0.033028 

Epoch 3
-------------------------------
loss: 2.121974  [    0/60000]
loss: 2.144973  [ 6400/60000]
loss: 2.049951  [12800/60000]
loss: 2.025212  [19200/60000]
loss: 2.119183  [25600/60000]
loss: 2.028407  [32000/60000]
loss: 2.016531  [38400/60000]
loss: 1.999072  [44800/60000]
loss: 1.939542  [51200/60000]
loss: 1.869733  [57600/60000]
Test Error: 
 Accuracy: 47.2%, Avg loss: 0.030161 

Epoch 4
-------------------------------
loss: 1.966496  [    0/60000]
loss: 2.005283  [ 6400/60000]
loss: 1.842639  [12800/60000]
loss: 1.798291  [19200/60000]
loss: 1.996712  [25600/60000]
loss: 1.860519  [32000/60000]
loss: 1.833745  [38400/60000]
loss: 1.834117  [44800/60000]
loss: 1.752414  [51200/60000]
loss: 1.658906  [57600/60000]
Test Error: 
 Accuracy: 48.4%, Avg loss: 0.027377 

Epoch 5
-------------------------------
loss: 1.817958  [    0/60000]
loss: 1.873164  [ 6400/60000]
loss: 1.658233  [12800/60000]
loss: 1.604004  [19200/60000]
loss: 1.892859  [25600/60000]
loss: 1.728574  [32000/60000]
loss: 1.694584  [38400/60000]
loss: 1.716881  [44800/60000]
loss: 1.620669  [51200/60000]
loss: 1.520065  [57600/60000]
Test Error: 
 Accuracy: 51.3%, Avg loss: 0.025398 

Epoch 6
-------------------------------
loss: 1.705050  [    0/60000]
loss: 1.772956  [ 6400/60000]
loss: 1.524106  [12800/60000]
loss: 1.473383  [19200/60000]
loss: 1.793820  [25600/60000]
loss: 1.624757  [32000/60000]
loss: 1.595235  [38400/60000]
loss: 1.626289  [44800/60000]
loss: 1.523839  [51200/60000]
loss: 1.426233  [57600/60000]
Test Error: 
 Accuracy: 53.5%, Avg loss: 0.023906 

Epoch 7
-------------------------------
loss: 1.612589  [    0/60000]
loss: 1.694386  [ 6400/60000]
loss: 1.419676  [12800/60000]
loss: 1.378877  [19200/60000]
loss: 1.704812  [25600/60000]
loss: 1.536829  [32000/60000]
loss: 1.516409  [38400/60000]
loss: 1.551574  [44800/60000]
loss: 1.448999  [51200/60000]
loss: 1.354901  [57600/60000]
Test Error: 
 Accuracy: 54.4%, Avg loss: 0.022727 

Epoch 8
-------------------------------
loss: 1.532547  [    0/60000]
loss: 1.630929  [ 6400/60000]
loss: 1.336020  [12800/60000]
loss: 1.305433  [19200/60000]
loss: 1.631139  [25600/60000]
loss: 1.462314  [32000/60000]
loss: 1.452916  [38400/60000]
loss: 1.491249  [44800/60000]
loss: 1.388288  [51200/60000]
loss: 1.299752  [57600/60000]
Test Error: 
 Accuracy: 55.3%, Avg loss: 0.021782 

Epoch 9
-------------------------------
loss: 1.462481  [    0/60000]
loss: 1.578309  [ 6400/60000]
loss: 1.268808  [12800/60000]
loss: 1.243797  [19200/60000]
loss: 1.572057  [25600/60000]
loss: 1.400606  [32000/60000]
loss: 1.401813  [38400/60000]
loss: 1.444131  [44800/60000]
loss: 1.337315  [51200/60000]
loss: 1.257235  [57600/60000]
Test Error: 
 Accuracy: 55.8%, Avg loss: 0.021020 

Epoch 10
-------------------------------
loss: 1.402163  [    0/60000]
loss: 1.532682  [ 6400/60000]
loss: 1.213558  [12800/60000]
loss: 1.192357  [19200/60000]
loss: 1.524502  [25600/60000]
loss: 1.349040  [32000/60000]
loss: 1.359848  [38400/60000]
loss: 1.406721  [44800/60000]
loss: 1.294481  [51200/60000]
loss: 1.222457  [57600/60000]
Test Error: 
 Accuracy: 56.7%, Avg loss: 0.020403 

Epoch 11
-------------------------------
loss: 1.351255  [    0/60000]
loss: 1.496092  [ 6400/60000]
loss: 1.168390  [12800/60000]
loss: 1.149713  [19200/60000]
loss: 1.487448  [25600/60000]
loss: 1.306274  [32000/60000]
loss: 1.324405  [38400/60000]
loss: 1.376118  [44800/60000]
loss: 1.258274  [51200/60000]
loss: 1.193912  [57600/60000]
Test Error: 
 Accuracy: 57.4%, Avg loss: 0.019891 

Epoch 12
-------------------------------
loss: 1.305900  [    0/60000]
loss: 1.466068  [ 6400/60000]
loss: 1.130126  [12800/60000]
loss: 1.114587  [19200/60000]
loss: 1.458147  [25600/60000]
loss: 1.270395  [32000/60000]
loss: 1.293715  [38400/60000]
loss: 1.350162  [44800/60000]
loss: 1.227087  [51200/60000]
loss: 1.169333  [57600/60000]
Test Error: 
 Accuracy: 58.3%, Avg loss: 0.019452 

Epoch 13
-------------------------------
loss: 1.264979  [    0/60000]
loss: 1.439438  [ 6400/60000]
loss: 1.097137  [12800/60000]
loss: 1.085567  [19200/60000]
loss: 1.433970  [25600/60000]
loss: 1.239276  [32000/60000]
loss: 1.266291  [38400/60000]
loss: 1.327267  [44800/60000]
loss: 1.199434  [51200/60000]
loss: 1.148261  [57600/60000]
Test Error: 
 Accuracy: 59.0%, Avg loss: 0.019064 

Epoch 14
-------------------------------
loss: 1.227596  [    0/60000]
loss: 1.414626  [ 6400/60000]
loss: 1.067816  [12800/60000]
loss: 1.061232  [19200/60000]
loss: 1.413360  [25600/60000]
loss: 1.212436  [32000/60000]
loss: 1.240914  [38400/60000]
loss: 1.306429  [44800/60000]
loss: 1.174499  [51200/60000]
loss: 1.129985  [57600/60000]
Test Error: 
 Accuracy: 59.8%, Avg loss: 0.018713 

Epoch 15
-------------------------------
loss: 1.192792  [    0/60000]
loss: 1.391189  [ 6400/60000]
loss: 1.041390  [12800/60000]
loss: 1.040678  [19200/60000]
loss: 1.396070  [25600/60000]
loss: 1.188643  [32000/60000]
loss: 1.217234  [38400/60000]
loss: 1.287394  [44800/60000]
loss: 1.151905  [51200/60000]
loss: 1.113297  [57600/60000]
Test Error: 
 Accuracy: 60.6%, Avg loss: 0.018389 

Done!

처음에 정확도 좋지 않을 수 있음
에폭 수 늘리거나 learning_rate 증가 고려
선택한 모델이 최적의 모델이 아닐 수 있음

모델 저장(Saving Models)

모델을 저장하는 일반적인 방법:
internal state dictionary를 직렬화(serialize)하는 것

torch.save(model.state_dict(), "data/model.pth")
print("Saved PyTorch Model State to model.pth")


Saved PyTorch Model State to model.pth

모델 불러오기(Loading Models)

모델 로드하는 프로세스:

모델의 구조 생성
구조에 internal state dictionary 로드

model = NeuralNetwork()
model.load_state_dict(torch.load("data/model.pth"))


<All keys matched successfully>

위 모델 사용하여 예측 가능

classes = [
    "T-shirt/top",
    "Trouser",
    "Pullover",
    "Dress",
    "Coat",
    "Sandal",
    "Shirt",
    "Sneaker",
    "Bag",
    "Ankle boot",
]

model.eval()
x, y = test_data[0][0], test_data[0][1]
with torch.no_grad():
    pred = model(x)
    predicted, actual = classes[pred[0].argmax(0)], classes[y]
    print(f'Predicted: "{predicted}", Actual: "{actual}"')


Predicted: "Sandal", Actual: "Ankle boot"

튜토리얼 완료

요약(Summary)

현재까지 신경망 사용하여 기계 학습 모델 구축하는 핵심 개념 공부 및 pytorch로 구현
FashionMNIST 이용한 이미지 분류 모델 구축함
다음과 같은 분야 배움
Tensor를 CPU, GPU와 함께 사용하는 방법
데이터셋 manage, scale, normalize 방법
신경망을 사용하여 모델을 구축하는 방법
모델 최적화 방법
모델 추론 최적화 방법(model.eval(), with torch.no_grad(), require_grad=False, tensor.detach() 등)

require_grad=False:
텐서에 대한 그래디언트가 역방향 패스 중에 계산되어야 하는지 여부를 나타내는 PyTorch 텐서의 속성
기본적으로 PyTorch에 의해 생성된 모든 텐서: requires_grad=True
False인 경우 텐서에 대한 그래디언트는 역방향 전달 중에 계산되지 않으며 텐서의 grad 속성은 업데이트되지 않음
torch.no_grad():
블록 내의 모든 텐서에 대한 그래디언트 추적을 일시적으로 비활성화하는 PyTorch에서 제공하는 컨텍스트 관리자
그래디언트 추적이 비활성화되면 포워드 패스가 평소와 같이 수행되지만 그래디언트가 계산되지 않고 텐서의 그래드 속성이 업데이트되지 않음
그래디언트가 필요하지 않을 때 계산 속도를 높이고 메모리를 절약하는 데 유용할 수 있음
detach():
원래 텐서와 동일한 저장소를 공유하지만 그래디언트 추적이 비활성화된 새 텐서를 반환하는 PyTorch에서 제공하는 메서드
원래 텐서는 수정되지 않지만 새 텐서는 기울기가 계산되지 않으며 grad 속성이 업데이트되지 않음
사용자가 추가 계산을 위해 원래 텐서를 유지하고 싶지만 기울기가 흐르는 것을 방지하려는 경우에 유용할 수 있음

요약:
requires_grad=False: 텐서에 대한 그래디언트 추적을 영구적으로 비활성화하는 방법
torch.no_grad(): 그래디언트 추적을 일시적으로 비활성화하는 컨텍스트 관리자
detach(): 텐서를 계산 기록에서 분리하는 방법으로 유용할 수 있음, 그래디언트 흐르는 것 방지

[PyTorch] 공식 문서 Learn the Basics 요약 - 7. Save and load the model

대두코기 — Sat, 21 Jan 2023 02:47:59 +0900

모델 저장하고 불러오기(Save and load the model)

모델 가중치 저장하고 불러오기(Saving and Loading Model Weights)

모델의 형태를 포함하여 저장하고 불러오기(Saving and Loading Models with Shapes)

모델 추론(Model Inference)

모델을 ONNX로 내보내기(Exporting the model to ONNX)

keyword:

torch.save, model.state_dict(), model.load_state_dict(), torch.load(), pickle module, 직렬화(serialize), 역직렬화(deserialize), model.eval(), 드롭아웃(dropout), 배치 정규화(batch normalization), %matplotlib inline, ONNX(Open Neural Network Exchange), onnxruntime, torch.onnx, Java, JavaScript, C#, ML.NET, 실행 그래프(execution graph), ONNX 내보내기(ONNX export), Persist, model.onnx, onnx.export, onnxruntime.InferenceSession, onnxruntime.InferenceSession.get_inputs(), onnxruntime.InferenceSession.run()

모델 저장하고 불러오기(Save and load the model)

이번 장에서는 저장하기나 불러오기를 통해 모델의 상태를 유지(persist)하고 모델의 예측을 실행하는 방법을 알아보겠습니다.

import torch
import torchvision.models as models

모델 가중치 저장하고 불러오기(Saving and Loading Model Weights)

PyTorch 모델은 학습한 매개변수를 state_dict라고 불리는 내부 상태 사전(internal state dictionary)에 저장합니다. 이 상태 값들은 torch.save 메소드를 사용하여 저장(persist)할 수 있습니다.

model = models.vgg16(pretrained=True)
torch.save(model.state_dict(), 'model_weights.pth')

모델 가중치를 불러오기 위해서는, 먼저 동일한 모델의 인스턴스(instance)를 생성한 다음에 load_state_dict() 메소드를 사용하여 매개변수들을 불러옵니다.

model = models.vgg16() # 기본 가중치를 불러오지 않으므로 pretrained=True를 지정하지 않습니다.
model.load_state_dict(torch.load('model_weights.pth'))
model.eval()

추론(inference)을 하기 전에 model.eval() 메소드를 호출하여 드롭아웃(dropout)과 배치 정규화(batch normalization)를 평가 모드(evaluation mode)로 설정해야 합니다. 그렇지 않으면 일관성 없는 추론 결과가 생성됩니다.

모델의 형태를 포함하여 저장하고 불러오기(Saving and Loading Models with Shapes)

모델의 가중치를 불러올 때, 신경망의 구조를 정의하기 위해 모델 클래스를 먼저 생성(instantiate)해야 했습니다. 이 클래스의 구조를 모델과 함께 저장하고 싶으면, (model.state_dict()가 아닌) model 을 저장 함수에 전달합니다:

torch.save(model, 'model.pth')

다음과 같이 모델을 불러올 수 있습니다:

model = torch.load('model.pth')

이 접근 방식은 Python pickle 모듈을 사용하여 모델을 직렬화(serialize)하므로, 모델을 불러올 때 실제 클래스 정의(definition)를 적용(rely on)합니다.

keyword: torch.save, model.state_dict(), model.load_state_dict(), torch.load(), pickle module, 직렬화(serialize), 역직렬화(deserialize), model.eval(), 드롭아웃(dropout), 배치 정규화(batch normalization)

torch.save:
모델의 매개변수와 옵티마이저의 상태를 포함하여 PyTorch 모델의 상태를 저장하는 데 사용되는 함수
나중에 torch.load 기능을 사용하여 로드할 수 있는 파일에 모델을 저장
또한 옵티마이저의 state_dict를 저장하므로 옵티마이저는 중단된 위치에서 학습을 다시 시작할 수 있음
모델을 함께 저장할 수 있으며, 이때는 매개변수로 model을 입력하면 됨
model.state_dict():
모델의 학습 가능한 모든 매개변수를 포함하는 정렬된 사전(ordered dictionary)을 반환하는 함수
리턴 값인 정렬된 사전은 torch.save 함수를 사용하여 모델의 현재 상태를 저장하거나 model.load_state_dict() 함수를 사용하여 사전 훈련된 모델을 로드하는 데 사용할 수 있음
키: 매개변수의 이름
값: 해당 매개변수 값을 포함하는 텐서
model.load_state_dict():
이전에 저장된 state_dict에서 모델의 상태를 로드하는 데 사용되는 함수
state_dict를 가져와 저장된 매개변수 값을 모델의 매개변수에 매핑함
torch.load():
모델의 매개변수와 옵티마이저의 상태를 포함하여 이전에 저장된 PyTorch 모델을 로드하는 함수
파일 경로를 인수로 사용하고 model.load_state_dict()에 전달할 수 있는 사전을 반환
모델을 함께 불러올 수 있으며, 이때는 매개변수로 모델이 함께 저장된 path를 입력하면 됨
pickle module:
Python dictionary 및 list와 같은 개체를 직렬화(serialize) 및 역직렬화(deserialize)하는 데 사용됨
PyTorch 모델을 저장하고 로드하는 데에도 사용할 수 있음
torch.save 및 torch.load 함수보다 효율성이 떨어지므로 사용하지 않는 것이 좋음
--
피클 모듈을 사용하여 PyTorch 모델을 저장하고 로드하는 것은 일반적으로 권장되지 않음
옵티마이저의 내부 상태(internal state) 및 모델의 역방향 전달 기록(backward pass history of the model)과 같이 모델을 올바르게 재구성하는 데 필요한 모든 정보를 처리하지 못할 수 있기 때문
대신 PyTorch 모델을 처리하도록 특별히 설계되었으며 모델을 올바르게 재구성하는 데 필요한 모든 정보를 저장하고 로드할 수 있는 torch.save 및 torch.load 함수를 사용하는 것이 좋음
--
그러나 이전에 pickle 모듈을 사용하여 모델을 저장한 경우 pickle.load() 함수를 사용하여 객체를 역직렬화하고 모델과 해당 속성을 다시 가져올 수 있음
그런 다음 model.load_state_dict()를 사용하여 모델의 상태 사전(state dictionary)을 로드하고 optimizer.load_state_dict()를 사용하여 옵티마이저의 상태 사전을 로드하고 옵티마이저를 모델로 설정할 수 있음
pickle로 모델을 저장한 후 PyTorch 버전이 변경되면 로드 프로세스가 제대로 작동하지 않을 수 있다는 점 유의

직렬화(serialize):
PyTorch 모델과 같은 복잡한 개체 또는 데이터 구조를 저장하거나 전송할 수 있는 형식으로 변환하는 프로세스
이 프로세스를 개체 "pickling" 또는 "flattening"라고도 함
torch.save 함수는 PyTorch 모델을 직렬화하는 데 사용할 수 있음
역직렬화(deserialize):
PyTorch 모델과 같은 직렬화된 개체 또는 데이터 구조를 다시 원래 형식으로 변환하는 프로세스
이 프로세스를 개체 "unpickling" 또는 "inflating"이라고도 힘
torch.load 함수는 PyTorch 모델을 역직렬화하는 데 사용할 수 있음
model.eval():
모델을 평가 모드로 설정하는 메서드
테스트 데이터에 대한 모델의 성능을 평가할 때 사용됨
평가 모드는 드롭아웃 및 배치 정규화와 같은 특정 기능을 해제하는 데 사용됨
드롭아웃(dropout):
훈련 중에 입력 단위의 일부를 무작위로 0으로 설정하는 정규화 기술
모델의 복잡성을 줄이고 활성화에 약간의 노이즈를 도입하여 과적합을 방지하는 데 도움을 줌
일반적으로 학습 중에만 사용되며 평가 또는 추론 중에는 사용되지 않음
배치 정규화(batch normalization):
평균을 빼고 표준 편차로 나누어 계층의 활성화(activations of layer)를 정규화하는 기술
내부 공변량 변화(internal covariate shift)를 줄여 훈련 과정을 안정화하는 데 도움을 줌
일반적으로 훈련 중에만 사용되며 평가 또는 추론 중에는 사용되지 않음

모델 추론(Model Inference)

모델 최적화: 어려운 작업, 다양한 프레임워크 및 하드웨어에서 성능을 최대화하는 데 시간이 많이 소요됨
ONNX(Open Neural Network Exchange) 런타임: 모든 하드웨어, 클라우드 또는 에지 장치에서 한 번 훈련하고 추론을 가속화하는 솔루션
ONNX: 신경망 및 기타 기계 학습 모델을 공유하기 위해 여러 공급업체에서 지원하는 공통 형식
ONNX 이점: Java, JavaScript, C# 및 ML.NET과 같은 다른 프로그래밍 언어 및 프레임워크에서 모델로 추론 가능

다른 예제 코드

%matplotlib inline
import torch
import onnxruntime
from torch import nn
import torch.onnx as onnx
import torchvision.models as models
from torchvision import datasets
from torchvision.transforms import ToTensor

class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(28*28, 512),
            nn.ReLU(),
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10),
            nn.ReLU()
        )

    def forward(self, x):
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits


model = NeuralNetwork()
model.load_state_dict(torch.load('data/model.pth'))
model.eval()

keyword: %matplotlib inline, Open Neural Network Exchange (ONNX), onnxruntime, torch.onnx, Java, JavaScript, C#, ML.NET

%matplotlib inline:
Jupyter 노트북에서 matplotlib 라이브러리로 생성된 플롯을 별도의 창이 아닌 노트북 내에서 표시하는 데 사용되는 명령
일반적으로 시간 경과에 따른 손실 또는 정확도와 같은 모델의 성능을 시각화하는 데 사용됨
ONNX(Open Neural Network Exchange):
딥 러닝 모델을 나타내는 개방형 형식
PyTorch 및 TensorFlow와 같은 서로 다른 프레임워크 간의 상호 운용성을 허용하고 모델을 내보내고 가져올 수 있음
onnxruntime:
ONNX 모델을 위한 고성능 추론 엔진
다양한 플랫폼과 하드웨어를 지원하며 모델의 추론 프로세스를 가속화하는 데 사용할 수 있음
torch.onnx:
모델을 ONNX 형식으로 내보낼 수 있는 PyTorch 패키지
PyTorch 모델을 ONNX로 변환하기 위한 간단한 API를 제공
모델을 ONNX를 지원하는 다른 프레임워크 또는 플랫폼으로 쉽게 내보낼 수 있음
Java:
모바일 및 웹 애플리케이션에서 엔터프라이즈 소프트웨어 및 과학 시뮬레이션에 이르기까지 광범위한 애플리케이션을 개발하는 데 널리 사용되는 널리 사용되는 프로그래밍 언어
Weka, Deeplearning4j 및 MLlib와 같은 기계 학습에 사용할 수 있는 라이브러리 및 프레임워크의 대규모 에코시스템 존재
JavaScript:
주로 웹 애플리케이션 개발에 사용되는 인기 있는 프로그래밍 언어
TensorFlow.js, Brain.js 및 ML.js와 같은 라이브러리의 도움으로 기계 학습 애플리케이션 개발에도 사용할 수 있음
C#:
주로 Windows 데스크톱 응용 프로그램, 모바일 앱 및 게임 개발에 사용되는 널리 사용되는 프로그래밍 언어
Accord.NET, ML.NET 및 CNTK와 같은 라이브러리의 도움으로 기계 학습 응용 프로그램 개발에도 사용할 수 있음
ML.NET:
.NET 개발자를 위한 오픈 소스 기계 학습 프레임워크
기계 학습에 대한 전문 지식 없이도 C# 또는 F#을 사용하여 기계 학습 모델을 개발할 수 있음
초보자와 전문가 모두를 위해 설계되었으며 분류, 회귀 및 이상 탐지와 같은 광범위한 기계 학습 작업을 지원

모델을 ONNX로 내보내기(Exporting the model to ONNX)

PyTorch: 기본 ONNX 내보내기 지원
PyTorch 실행 그래프의 동적 특성(Dynamic nature of PyTorch execution graph):
내보내기 프로세스는 유지되는(persisted) ONNX 모델을 생성하기 위해 실행 그래프를 통과해야 함
테스트 변수: 내보내기 루틴에 전달, 올바른 크기의 더미 제로 텐서(훈련 데이터 세트의 shape에서 얻을 수 있음)

input_image = torch.zeros((1,28,28))
onnx_model = 'data/model.onnx'
onnx.export(model, input_image, onnx_model)

테스트 데이터 세트: 예측을 위해 ONNX 모델에서 추론하기 위한 샘플 데이터로 사용
추론 세션: onnxruntime.InferenceSession으로 생성됨
추론: 원하는 출력 목록과 입력 값 맵을 전달하여 run() 메서드를 사용하여 ONNX 모델에서 수행됨
결과: 출력 목록

session = onnxruntime.InferenceSession(onnx_model, None)
input_name = session.get_inputs()[0].name
output_name = session.get_outputs()[0].name

result = session.run([output_name], {input_name: x.numpy()})
predicted, actual = classes[result[0][0].argmax(0)], classes[y]
print(f'Predicted: "{predicted}", Actual: "{actual}"')

ONNX 모델: 다양한 플랫폼과 다양한 프로그래밍 언어에서 추론을 실행하는 데 사용할 수 있음

keyword: 실행 그래프(execution graph), ONNX 내보내기(ONNX export), Persist, model.onnx, onnx.export, onnxruntime.InferenceSession, onnxruntime.InferenceSession.get_inputs(), onnxruntime.InferenceSession.run()

실행 그래프(execution graph):
모델이 수행하는 계산을 그래프 기반으로 표현한 것
입력에 대해 수행되는 작업과 실행 순서를 설명함
모델의 성능을 최적화하고 모델을 다른 프레임워크나 플랫폼으로 내보낼 수 있도록 하는 데 사용됨
ONNX 내보내기(ONNX export):
하나의 프레임워크에서 딥 러닝 모델을 표현하기 위한 개방형 형식인 ONNX 형식으로 모델을 변환하는 프로세스
이를 통해 PyTorch 및 TensorFlow와 같은 서로 다른 프레임워크 간의 상호 운용성을 허용하고 모델을 내보내고 가져올 수 있음
일반적으로 PyTorch의 torch.onnx 패키지를 사용하여 수행됨
Persist:
나중에 로드하여 사용할 수 있도록 모델의 상태를 파일에 저장하는 프로세스
이를 통해 학습 후 모델을 저장하여 추론 또는 추가 학습에 사용할 수 있음
PyTorch에서 torch.save() 및 torch.load() 함수를 사용하거나 모델에서 state_dict() 및 load_state_dict() 메서드를 사용하여 state_dict를 저장 및 로드함으로써 수행할 수 있음

model.onnx:
훈련된 모델을 ONNX 형식으로 저장하기 위한 파일 형식
딥 러닝 모델을 표현하기 위한 개방형 형식으로, PyTorch 및 TensorFlow와 같은 서로 다른 프레임워크 간의 상호 운용성을 허용
onnx.export:
PyTorch의 torch.onnx 패키지에서 제공하는 함수
PyTorch 모델을 ONNX 형식으로 내보낼 수 있음
모델, 예제 입력 텐서 및 파일 경로를 인수로 사용
모델을 지정된 파일 경로로 내보냄
제공한 코드 스니펫에서 모델은 'data/model.onnx' 파일로 내보내지며 입력 텐서는 모양이 (1, 28, 28)이고 0으로 채워져 있ㅇ,ㅁ

onnxruntime.InferenceSession:
ONNX 모델 실행을 위한 세션을 나타내는 ONNX 런타임 라이브러리의 클래스
ONNX 모델을 로드하고, 추론을 위해 준비하고, 모델에서 추론을 실행하는 데 사용됨
ONNX 모델 파일의 경로를 가져와서 모델에서 추론을 실행하는 데 사용할 수 있는 세션 개체를 만듬
onnxruntime.InferenceSession.get_inputs():
모델의 입력 텐서 목록을 반환하는 onnxruntime.InferenceSession 클래스의 메서드
모델의 입력 텐서를 가져오고 올바른 형식으로 입력 데이터를 준비하는 데 사용됨
onnxruntime.InferenceSession.run():
모델에서 추론을 실행하는 onnxruntime.InferenceSession 클래스의 메서드
입력 및 출력 텐서의 이름과 입력 데이터를 받아 출력 데이터를 반환
주어진 입력 데이터로 모델에 대한 추론을 수행하는 데 사용됨
모델에서 생성된 출력 데이터를 반환

[PyTorch] 공식 문서 Learn the Basics 요약 - 6. Optimization

대두코기 — Fri, 20 Jan 2023 17:16:14 +0900

모델 매개변수 최적화(Optimizing the model parameters)

기본 코드(Prerequisite code)

하이퍼파라미터 설정(Setting hyperparameters)

최적화 루프 추가(Add an optimization loop)

손실 함수 추가(Add a loss function)

최적화 패스(Optimization pass)

전체 구현(Full implementation)

keyword:

학습률(learning rate), 최상의 가중치(best weights), 예측할 수 없는 동작(unpredictable behavior), 지역 최소값(local minima), 전역 최소값(global minima), 최적화 루프(optimization loop), 학습 루프(train loop), 검증 루프(validation loop), 테스트 루프(test loop), 손실 계산(loss calculation), 옵티마이저 단계(optimizer step), 평균 제곱 오차(Mean Square Error, MSE), 음의 로그 우도(Negative Log Likelihood, NLL), 크로스엔트로피 손실(Cross-Entropy Loss, CE), 로짓(logit), 최적화 알고리즘(optimization algorithms), 옵티마이저 객체(optimizer object), SGD(Stochastic Gradient Descent), ADAM, RMSProp, torch.save, 내부 상태 사전(internal state dictionary), state_dict()

모델 매개변수 최적화(Optimizing the model parameters)

모델: 훈련, 검증 및 테스트됨
데이터: 최적화에 사용
학습: 반복적인 과정 거침
반복(iteration): epoch(에폭)라고 함
각 반복에서의 모델의 학습:
출력에 대해 추측
오류(추측과 정답 사이의 차이(손실, loss)) 계산
매개변수와 관련된 오류의 도함수(derivative) 수집
경사하강법(Gradient Descent) 사용하여 매개변수 최적화(optimize)

keyword: model optimization

모델 최적화(model optimization):
손실 함수와 같은 스칼라 값 함수를 최소화하기 위해 모델의 매개변수를 조정하는 프로세스
손실 함수의 변화도를 기반으로 매개변수를 업데이트하는 알고리즘인 옵티마이저를 사용하여 수행됨
목표는 최상의 모델 성능을 나타내는 가능한 최저 손실(lowest possible loss)을 초래하는 매개변수 집합을 찾는 것

기본 코드(Prerequisite code)

%matplotlib inline
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor, Lambda

training_data = datasets.FashionMNIST(
    root="data",
    train=True,
    download=True,
    transform=ToTensor()
)

test_data = datasets.FashionMNIST(
    root="data",
    train=False,
    download=True,
    transform=ToTensor()
)

train_dataloader = DataLoader(training_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)

class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(28*28, 512),
            nn.ReLU(),
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10),
            nn.ReLU()
        )

    def forward(self, x):
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits

model = NeuralNetwork()

하이퍼파라미터 설정(Setting hyperparameters)

하이퍼파라미터

정의: 모델 최적화 과정을 제어하는 조절 가능한 매개변수
영향(impact): 모델 학습 및 정확도 수준, 수렴율(convergence rate)
학습용으로 정의된 하이퍼파라미터:
- Epoch 수: 전체 교육 데이터 세트가 네트워크를 통과하는 횟수
- batch size: 매개변수가 갱신되기 전 신경망을 통해 전파된 데이터 샘플의 수
- iterations(반복수): 한 에폭를 완료하는 데 필요한 배치 수(학습 데이터 수 / 배치 사이즈)
- 학습률(learning rate):
  각 배치/에폭에서 모델의 매개변수를 조절하는 비율
  더 작은 학습률: 학습 속도 느려짐. 모델이 최상의 가중치를 찾는 데 더 오래 걸림. local minima에 빠질 수 있음
  더 큰 학습률: 모델이 건너뛰고 최상의 가중치를 놓칠 수 있으며 학습 중에 예측할 수 없는 동작이 발생할 수 있음

learning_rate = 1e-3
batch_size = 64
epochs = 5

keyword: learning rate, best weights, unpredictable behavior, local minima, global minima

학습률(learning rate):
최적화 알고리즘의 단계 크기를 제어하는 하이퍼파라미터
각 반복에서 매개변수가 업데이트되는 양을 결정
학습률이 높으면 업데이트가 커지고 수렴이 빨라지지만 모델이 최적의 솔루션을 초과할 수도 있음
학습률이 낮으면 업데이트가 작아지고 수렴이 느려지지만 로컬 미니마에 갇힐 수 있음
최상의 가중치(best weights):
최상의 모델 성능을 나타내는 가능한 최저 손실(lowest possible loss)을 초래하는 매개변수 집합
옵티마이저의 목표는 손실 함수의 기울기에 따라 매개변수를 업데이트하여 모델에 가장 적합한 가중치를 찾는 것
예측할 수 없는 동작(unpredictable behavior):
옵티마이저가 최상의 가중치를 찾을 수 없는 경우 모델 최적화 프로세스 중에 예측할 수 없는 동작이 발생할 수 있음
이는 잘못된 하이퍼 매개변수 선택(poor choice of hyperparameter), 잘못 확장된 데이터(poorly scaled data) 또는 복잡하고 고차원적인 문제(complex, high-dimonsional problem)와 같은 여러 요인으로 인해 발생할 수 있음
옵티마이저가 차선의 솔루션이 될 수 있는 로컬 미니멈 또는 안장점(saddle point)에 멈춘 경우에도 발생할 수 있음
지역 최소값(local minima):
근처의 모든 지점보다 낮은 손실 함수 환경의 한 지점
더 낮은 지점이 있을 수 있음
로컬 최소값으로 수렴하도록 훈련된 모델은 전역 최소값으로 수렴하는 모델보다 성능이 좋지 않음
전역 최소값(global minima):
전체적으로 가장 낮은 지점인 손실 함수 환경의 지점
전역 최소값으로 수렴하도록 훈련된 모델이 최상의 성능을 발휘

최적화 단계 추가(Add an optimization loop)

최적화 단계: 모델 학습 및 최적화에 사용
각 에폭: 두 가지 주요 부분으로 구성
- 훈련 루프: 훈련 데이터 세트를 반복하고 최적의 매개변수로 수렴하려고 시도
- 검증/테스트 단계(validation/test loop): 테스트 데이터 세트를 반복하여 모델 성능이 개선되고 있는지 확인
교육 루프에서 사용되는 개념:
- forward pass: 모델이 예측을 수행
- loss calculation: 예측을 실제 출력과 비교
- backward pass: 모델 매개변수에 대한 손실의 기울기를 계산
- optimizer step: 계산된 그래디언트를 사용하여 모델 매개변수를 업데이트

키워드: optimization loop, train loop, validation loop, test loop, generalization performance, loss calculation, optimizer step

최적화 루프(optimization loop):
신경망 학습 과정의 주요 루프
모델을 통해 입력 데이터를 반복적으로 전달하고, 손실을 계산하고, 옵티마이저를 사용하여 모델의 매개변수를 업데이트하는 것으로 구성됨
지정된 반복 횟수 동안 또는 모델 성능이 특정 임계값에 도달할 때까지 반복됨
학습 루프(train loop):
훈련 데이터에서 모델을 훈련시키는 데 사용되는 특정 유형의 최적화 루프
훈련 루프 동안 훈련 데이터에서 계산된 손실 함수의 기울기를 기반으로 모델의 매개변수가 업데이트됨
검증 루프(validation loop):
훈련 루프와 유사하지만 검증 데이터 세트에서 모델의 성능을 평가하는 데 사용됨
훈련 중 모델의 성능을 모니터링하고 과적합을 감지하는 데 사용됨
테스트 루프(test loop):
학습이 완료된 후 테스트 데이터 세트에서 모델의 성능을 평가하는 데 사용됨
모델의 일반화 성능에 대한 추정치를 제공
일반화 성능(generalization performance):
본 적이 없는 데이터에 대해 모델이 잘 수행할 수 있는 능력
손실 계산(loss calculation):
모델의 출력과 실제 출력에 대한 스칼라 값 함수를 계산하는 프로세스
모델의 매개변수를 업데이트하는 데 필요한 정보를 제공하므로 최적화 루프에서 중요한 단계
옵티마이저 단계(optimizer step):
손실 함수의 기울기에 따라 모델의 매개변수를 업데이트하는 프로세스

손실 함수 추가(Add a loss function)

학습 데이터 제공 시 학습되지 않은 네트워크는 정답을 제공하지 않을 수 있음
손실 함수: 목표 값에 대한 얻은 결과의 비 유사성(degree of dissimilarity)을 측정, 학습 중 최소화
손실 계산:
- 예측: 주어진 데이터 샘플을 모델에 입력
- 비교: 실제 데이터 레이블 값과 비교
일반적인 손실 함수:
- nn.MSELoss: 회귀 작업에 사용되는 Mean Square Error
- nn.NLLLoss: 분류에 사용되는 음의 로그 우도
- nn.CrossEntropyLoss:
  nn.LogSoftmax와 nn.NLLLoss를 합친 로스
예제에서는 nn.CrossEntropyLoss 사용, 모델의 출력 로짓을 전달하여 로짓을 정규화하고 예측 오류를 계산

# Initialize the loss function
loss_fn = nn.CrossEntropyLoss()

keyword: mean square error, negative log likelihood, cross-entropy loss, logits, normalization

평균 제곱 오차(Mean Square Error, MSE):
예측 출력과 실제 출력 간의 평균 제곱 차이를 측정하는 스칼라 값 함수
연속 값을 예측하는 것이 목표인 회귀 문제의 손실 함수로 자주 사용됨
이상치에 민감하며 작은 오류보다 큰 오류를 처벌(punish)함
음의 로그 우도(Negative Log Likelihood, NLL):
예측된 출력에서 실제 출력의 우도를 측정하는 스칼라 값 함수
이산 값을 예측하는 것이 목표인 분류 문제의 손실 함수로 자주 사용됨
음의 로그는 함수를 미분 가능하게 만드는 데 사용됨
음의 부호는 함수를 최소화해야 하는 손실 함수로 만드는 데 사용됨
크로스엔트로피 손실(Cross-Entropy Loss, CE):
예측된 출력과 실제 출력 간의 차이를 측정하는 스칼라 값 함수
이산 값을 예측하는 것이 목표인 분류 문제의 손실 함수로 자주 사용됨
NLL과 밀접한 관련이 있으며 출력의 확률을 얻기 위해 softmax activation function과 함께 자주 사용됨
로짓(logit):
활성화 함수가 적용되기 전 모델의 원시 출력
신경망에서 로짓은 softmax 함수가 적용되기 전 마지막 선형 레이어의 출력
로짓은 크로스 엔트로피 손실을 계산할 때 소프트맥스 함수가 나중에 적용되기 때문에 유용

최적화 패스(Optimization pass)

최적화: 각 학습 단계에서 모델 오류를 줄이기 위해 모델 매개변수를 조정하는 프로세스
최적화 알고리즘: 최적화 프로세스 수행 방법 정의(이 예에서는 Stochastic Gradient Descent가 사용됨)
옵티마이저 객체: 모든 최적화 로직을 캡슐화
SGD 옵티마이저: 이 예에서 사용되며 다른 옵션에는 ADAM 및 RMSProp 등이 있음
옵티마이저 초기화: 학습할 모델의 매개변수 및 학습률을 하이퍼파라미터로 전달하여 시행
학습 단계(loop)에서의 최적화: 3단계
1. optimizer.zero_grad(): 모델 매개변수의 그래디언트를 재설정. 그래디언트는 기본적으로 합산(accumulate)되기에 명시적으로 0으로 초기화 필요
2. loss.backwards(): 예측 손실(prediction loss)을 역전파. PyTorch는 각 매개변수에 대해 손실 변화도를 저장
3. optimizer.step(): 역전파 패스에서 수집된 그래디언트로 매개변수를 조정

optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

keyword: optimization algorithms, optimizer object, SGD, ADAM, RMSProp

최적화 알고리즘(optimization algorithms):
손실 함수와 같은 스칼라 값 함수를 최소화하기 위해 모델의 매개변수를 조정하는 데 사용되는 방법
일반적인 최적화 알고리즘에는 SGD(Stochastic Gradient Descent), Adam 및 RMSProp이 포함됨
각 알고리즘에는 학습 프로세스를 제어하는 학습 속도와 같은 고유한 하이퍼 매개변수 세트가 있음
옵티마이저 객체(optimizer object):
모델의 매개변수를 업데이트하는 데 사용되는 PyTorch의 SGD, Adam 또는 RMSProp과 같은 최적화 알고리즘의 인스턴스
모델의 매개변수를 원하는 하이퍼 매개변수와 함께 알고리즘의 생성자(constructor)에 전달하여 옵티마이저 객체를 생성할 수 있음
SGD(Stochastic Gradient Descent):
손실 함수의 음의 기울기 방향으로 단계를 진행하여 모델의 매개변수를 업데이트하는 간단한 최적화 알고리즘
계산적으로 효율적이며 광범위한 최적화 문제에 사용할 수 있지만 학습률 선택에 민감
ADAM:
과거 그래디언트 정보를 기반으로 각 매개변수의 학습률을 조정하는 최적화 알고리즘
이전 단계의 그래디언트 정보를 사용하여 단계 크기를 조정하므로 학습률 선택에 더욱 강건해짐
RMSProp:
과거 그래디언트 정보를 기반으로 각 매개변수의 학습률을 조정하는 최적화 알고리즘
그래디언트의 제곱의 이동 평균을 사용하여 단계 크기를 조정하므로 학습률 선택에 더 강건해짐

전체 구현(Full implementation)

train_loop: 최적화 코드를 반복하여 수행
test_loop: 테스트 데이터로 모델의 성능 측정
모델 학습 단계
- 손실 함수 정의
- 옵티마이저 초기화(모델의 매개변수 및 러닝레이트 전달)
- 에폭 수 정의 후 train_loop, test_loop 실행

성능 좋지 않을 시 epoch, learning_rate 등 조정 가능. 또는 모델이 적합하지 않을 수 있음. 이후 비전 문제에 대해 다룰 것

def train_loop(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)
    for batch, (X, y) in enumerate(dataloader):        
        # Compute prediction and loss
        pred = model(X)
        loss = loss_fn(pred, y)
        
        # Backpropagation
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if batch % 100 == 0:
            loss, current = loss.item(), batch * len(X)
            print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")


def test_loop(dataloader, model, loss_fn):
    size = len(dataloader.dataset)
    test_loss, correct = 0, 0

    with torch.no_grad():
        for X, y in dataloader:
            pred = model(X)
            test_loss += loss_fn(pred, y).item()
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
            
    test_loss /= size
    correct /= size
    print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")
    
    loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

epochs = 10
for t in range(epochs):
    print(f"Epoch {t+1}\n-------------------------------")
    train_loop(train_dataloader, model, loss_fn, optimizer)
    test_loop(test_dataloader, model, loss_fn)
print("Done!")


Epoch 1
-------------------------------
loss: 2.307260  [    0/60000]
loss: 2.305284  [ 6400/60000]
loss: 2.293966  [12800/60000]
loss: 2.291592  [19200/60000]
loss: 2.288022  [25600/60000]
loss: 2.259277  [32000/60000]
loss: 2.277950  [38400/60000]
loss: 2.252569  [44800/60000]
loss: 2.238333  [51200/60000]
loss: 2.239141  [57600/60000]
Test Error: 
 Accuracy: 27.5%, Avg loss: 0.035050 

Epoch 2
-------------------------------
loss: 2.222609  [    0/60000]
loss: 2.244805  [ 6400/60000]
loss: 2.209550  [12800/60000]
loss: 2.227453  [19200/60000]
loss: 2.217051  [25600/60000]
loss: 2.162092  [32000/60000]
loss: 2.206926  [38400/60000]
loss: 2.151579  [44800/60000]
loss: 2.117667  [51200/60000]
loss: 2.143689  [57600/60000]
Test Error: 
 Accuracy: 38.9%, Avg loss: 0.033368 

Epoch 3
-------------------------------
loss: 2.102783  [    0/60000]
loss: 2.154025  [ 6400/60000]
loss: 2.076486  [12800/60000]
loss: 2.124048  [19200/60000]
loss: 2.107713  [25600/60000]
loss: 2.014179  [32000/60000]
loss: 2.090220  [38400/60000]
loss: 1.989485  [44800/60000]
loss: 1.933911  [51200/60000]
loss: 2.002917  [57600/60000]
Test Error: 
 Accuracy: 41.2%, Avg loss: 0.030885 

Epoch 4
-------------------------------
loss: 1.926293  [    0/60000]
loss: 2.019496  [ 6400/60000]
loss: 1.888668  [12800/60000]
loss: 1.987653  [19200/60000]
loss: 1.968171  [25600/60000]
loss: 1.838344  [32000/60000]
loss: 1.951870  [38400/60000]
loss: 1.808960  [44800/60000]
loss: 1.749038  [51200/60000]
loss: 1.868777  [57600/60000]
Test Error: 
 Accuracy: 44.4%, Avg loss: 0.028537 

Epoch 5
-------------------------------
loss: 1.754023  [    0/60000]
loss: 1.889865  [ 6400/60000]
loss: 1.724985  [12800/60000]
loss: 1.880932  [19200/60000]
loss: 1.852289  [25600/60000]
loss: 1.703095  [32000/60000]
loss: 1.850078  [38400/60000]
loss: 1.679640  [44800/60000]
loss: 1.618462  [51200/60000]
loss: 1.781099  [57600/60000]
Test Error: 
 Accuracy: 46.4%, Avg loss: 0.026904 

Epoch 6
-------------------------------
loss: 1.629323  [    0/60000]
loss: 1.794621  [ 6400/60000]
loss: 1.609603  [12800/60000]
loss: 1.806047  [19200/60000]
loss: 1.771073  [25600/60000]
loss: 1.610854  [32000/60000]
loss: 1.782800  [38400/60000]
loss: 1.593032  [44800/60000]
loss: 1.530435  [51200/60000]
loss: 1.721836  [57600/60000]
Test Error: 
 Accuracy: 47.5%, Avg loss: 0.025738 

Epoch 7
-------------------------------
loss: 1.541017  [    0/60000]
loss: 1.723998  [ 6400/60000]
loss: 1.525540  [12800/60000]
loss: 1.745950  [19200/60000]
loss: 1.714844  [25600/60000]
loss: 1.542636  [32000/60000]
loss: 1.735072  [38400/60000]
loss: 1.529822  [44800/60000]
loss: 1.467118  [51200/60000]
loss: 1.675812  [57600/60000]
Test Error: 
 Accuracy: 48.3%, Avg loss: 0.024844 

Epoch 8
-------------------------------
loss: 1.474333  [    0/60000]
loss: 1.669000  [ 6400/60000]
loss: 1.460421  [12800/60000]
loss: 1.694097  [19200/60000]
loss: 1.674764  [25600/60000]
loss: 1.487773  [32000/60000]
loss: 1.699166  [38400/60000]
loss: 1.481064  [44800/60000]
loss: 1.419311  [51200/60000]
loss: 1.638599  [57600/60000]
Test Error: 
 Accuracy: 48.7%, Avg loss: 0.024137 

Epoch 9
-------------------------------
loss: 1.420322  [    0/60000]
loss: 1.625176  [ 6400/60000]
loss: 1.408073  [12800/60000]
loss: 1.649715  [19200/60000]
loss: 1.644693  [25600/60000]
loss: 1.443653  [32000/60000]
loss: 1.671596  [38400/60000]
loss: 1.443777  [44800/60000]
loss: 1.382555  [51200/60000]
loss: 1.608089  [57600/60000]
Test Error: 
 Accuracy: 49.1%, Avg loss: 0.023570 

Epoch 10
-------------------------------
loss: 1.375013  [    0/60000]
loss: 1.588062  [ 6400/60000]
loss: 1.364595  [12800/60000]
loss: 1.612044  [19200/60000]
loss: 1.621220  [25600/60000]
loss: 1.407904  [32000/60000]
loss: 1.649211  [38400/60000]
loss: 1.415225  [44800/60000]
loss: 1.353849  [51200/60000]
loss: 1.582835  [57600/60000]
Test Error: 
 Accuracy: 49.5%, Avg loss: 0.023104 

Done!

모델 저장(Saving Models)

모델 성능 만족 시 torch.save 사용하여 저장 가능

pytorch 모델은 state_dict라는 internal state dictionary에 매개변수 저장

These can be persisted(유지) with the torch.save method:

torch.save(model.state_dict(), "data/model.pth")

print("Saved PyTorch Model State to model.pth")

keyword: torch.save, internal state dictionary, state_dict

torch.save:
모델의 매개변수와 옵티마이저의 상태를 포함하여 PyTorch 모델의 상태를 저장하는 데 사용되는 함수
나중에 torch.load 기능을 사용하여 로드할 수 있는 파일에 모델을 저장
내부 상태 사전(internal state dictionary):
모델의 매개변수 및 옵티마이저의 상태를 포함하여 PyTorch 모델의 현재 상태를 포함하는 Python 사전
이 사전은 모델이나 옵티마이저의 state_dict() 함수를 사용하여 액세스할 수 있음
state_dict():
모델 또는 옵티마이저의 학습 가능한 모든 매개변수를 포함하는 정렬된 사전을 반환하는 함수
torch.save 함수를 사용하여 모델의 현재 상태를 저장하거나 torch.load 함수를 사용하여 사전 훈련된 모델을 로드하는 데 사용할 수 있음
키는 매개변수의 이름
값은 해당 매개변수 값을 포함하는 텐서

[PyTorch] 공식 문서 Learn the Basics 요약 - 5. Automatic differentiation with torch.autograd

대두코기 — Fri, 20 Jan 2023 12:45:38 +0900

torch.autograd를 사용한 자동 미분(Automatic differentiation with torch.autograd)

Tensor, Function과 연산 그래프(Tensors, Functions and Computational graph)

변화도 계산하기(Computing gradients)

변화도 추적 멈추기(Disabling gradient tracking)

연산 그래프에 대한 추가 정보(more on Computational Graphs)

선택적으로 읽기: 텐서 변화도와 야코비안 곱(Optional Reading: Tensor gradients and jacobian products)

Keywords: backpropagation, gradient, loss function, retraining, gradient descent, differentiation engine, computational graph, class Function in pytorch, forward direction, requires_grad property, grad_fn property, forward pass, backward pass, ∂loss/∂w, ∂loss/∂b, loss.backward(), w.grad, b.grad, leaf nodes, root node, backward call, retain_graph=True, torch.no_grad() block, gradient tracking, frozen parameter, fine tuning, autograd, directed acyclic graph, chain rule, dynamic graph, control flow statements, computation vs operation, cycle vs loop, scalar loss function, Jacobian matrix, vector function, Jacobian product, shape vs size on tensor, scalar-valued function, optimizer

torch.autograd를 사용한 자동 미분(Automatic differentiation with torch.autograd)

역전파: 신경망 훈련에 가장 자주 사용되는 알고리즘
손실 함수의 변화도(gradient)에 따라 매개변수(모델 가중치)를 조정
네트워크를 통해 역방향으로 이동하여 가중치와 편향을 조정하여 모델을 재훈련
손실 함수: 신경망의 예상 출력과 실제 출력 간의 차이를 계산
목표: 손실 함수를 0으로 최소화하는 것
경사하강법(gradient descent): 손실을 줄이기 위해 시간이 지남에 따라 모델을 재훈련(retraining)하는 프로세스
PyTorch에는 그래디언트 계산을 위한 torch.autograd라는 미분 엔진이 내장되어 있음
다음과 같이 간단한 1계층 신경망 입력 x, 매개변수 w 및 b, 손실 함수를 사용하여 정의할 수 있음

import torch

x = torch.ones(5)  # input tensor
y = torch.zeros(3)  # expected output
w = torch.randn(5, 3, requires_grad=True)
b = torch.randn(3, requires_grad=True)
z = torch.matmul(x, w)+b
loss = torch.nn.functional.binary_cross_entropy_with_logits(z, y)

Keywords: backpropagation, gradient, loss function, retraining, gradient descent, differentiation engine, computational graph

backpropagation:
신경망을 훈련하는 데 사용되는 알고리즘으로, 각 계층에서 오류를 계산하고 그에 따라 가중치를 업데이트하는 데 사용됨
gradient:
gradient descent과 같은 최적화 알고리즘에 사용되는 함수의 가장 급격한 증가(steepest increse)의 방향과 크기를 나타내는 벡터
loss function:
모델을 최적화하는 데 사용되는 함수
신경망에서 예측된 출력과 실제 출력 간의 오차 또는 차이를 측정하는 데 사용되는 함수
retraining:
성능을 향상시키기 위해 새로운 데이터에 대해 모델을 다시 훈련시키는 과정
gradient descent:
gradient의 반대 방향으로 weights를 조정하여 신경망에서 loss function을 최소화하는 데 사용되는 최적화 알고리즘
differentiation engine:
신경망의 다양한 연산에 대한 gradients를 계산하는 구성 요소(component)
backpropagation을 위한 gradients를 계산하는 데 사용됨
computational graph:
수학적 계산의 그래프 표현
신경망에서 backpropagation하는 동안 gradients를 효율적으로 계산하는 데 사용됨

Tensor, Function과 연산 그래프(Tensors, Functions and Computational graph)

위 코드로부터 정의된 computational graph

이 신경망에서는 매개변수 w와 b를 최적화해야 하고 기울기를 계산해야 함
그래디언트를 계산하려면 텐서의 requires_grad 속성 설정 필요
계산 그래프를 구성하기 위해 텐서에 적용되는 함수: Function 클래스의 개체
함수 개체는 순방향으로 함수를 계산하는 방법과 역방향 전파 중에 도함수를 계산하는 방법 알고 있음
역방향 전파 함수에 대한 참조(reference)는 텐서의 grad_fn 속성에 저장됨
텐서를 생성할 때(requires_grad=True 파라미터) 또는 나중에 x.requires_grad_(True) 메서드를 사용하여 requires_grad 값을 설정할 수 있음

print('Gradient function for z =',z.grad_fn)
print('Gradient function for loss =', loss.grad_fn)

Gradient function for z = <AddBackward0 object at 0x00000280CC630CA0>
Gradient function for loss = <BinaryCrossEntropyWithLogitsBackward object at 0x00000280CC630310>

Keywords: class Function in pytorch, forward direction, requires_grad property, grad_fn property, forward pass, backward pass

class 'Function' in pytorch:
신경망의 모든 작업에 대한 기본 클래스로 단일 정방향 계산을 나타냄
forward direction:
일반적으로 입력에서 출력으로 신경망에서 계산이 수행되는 방향
require_grad property:
PyTorch 텐서의 속성
역방향 전달(backward pass) 중에 텐서에 대한 그래디언트를 계산해야 하는지 여부를 나타냄
grad_fn property:
텐서를 생성한 함수를 참조하는 PyTorch 텐서의 속성
그래디언트를 계산하기 위해 backward pass에 사용됨
forward pass:
입력이 주어진 신경망의 출력을 계산하는 프로세스
입력 텐서로 시작하여 계산 그래프의 Function 클래스에 의해 정의된 일련의 작업을 적용하여 한 작업의 출력을 다음 작업의 입력으로 전달
forward pass의 결과는 일반적으로 loss 함수를 계산하는 데 사용되는 출력 텐서
backward pass:
모델의 매개변수에 대한 loss 함수의 그래디언트를 계산하는 프로세스
일반적으로 loss 텐서인 루트 노드에서 시작하여 chain rule of differentiation을 적용하여 계산 그래프의 모든 텐서에 대한 그래디언트를 계산
그래디언트는 텐서의 grad 속성에 저장되며 옵티마이저를 사용하여 모델의 매개변수를 업데이트하는 데 사용할 수 있음
backward pass는 루트 텐서에서 backward() 메서드를 호출하여 수행됨

class 'Function' in pytorch 상세

PyTorch의 Function 클래스는 신경망에서 계산을 만들고 표현하기 위한 기본 빌딩 블록입니다. 행렬 곱셈 또는 비선형 활성화 함수와 같은 특정 연산의 정방향 계산을 정의하는 데 사용됩니다. 또한 그래디언트를 계산하기 위해 역방향 패스에서 사용되는 계산의 입력 및 출력 텐서에 대한 정보를 보유합니다.
사용자는 Function을 서브클래싱하고 입력 텐서에서 수행되는 계산을 정의하고 출력 텐서를 반환하는 전달 메서드를 구현하여 새 작업을 정의할 수 있습니다. 입력 텐서에 대한 기울기를 계산하는 역방향 방법은 autograd 패키지를 사용하여 PyTorch에 의해 자동으로 정의됩니다.
신경망에서 계산이 수행되면 PyTorch는 해당 Function 클래스의 인스턴스를 생성하고 전달 메서드를 호출합니다. 순방향 메서드에서 반환된 출력 텐서는 grad_fn 속성과 연결되어 있어 PyTorch가 계산을 추적하고 역방향 패스 중에 그래디언트를 계산할 수 있습니다.
또한 기본적으로 PyTorch에 의해 생성된 모든 텐서에는 require_grad=False가 있습니다. 즉, 이 텐서에 대한 그래디언트는 역방향 패스 중에 계산되지 않습니다. 그러나 텐서에 require_grad=True를 설정하면 그래디언트가 계산되어 텐서를 역방향 전달에 사용할 수 있고 사용자가 최적화 프로그램을 사용하여 모델의 매개변수를 업데이트할 수 있습니다.

The Function class in PyTorch is a fundamental building block for creating and representing computations in a neural network. It is used to define the forward computation of a specific operation, such as a matrix multiplication or a non-linear activation function. It also holds information about the input and output tensors of the computation, which are used in the backward pass to compute gradients.
A user can define a new operation by subclassing Function and implementing the forward method, which defines the computation performed on the input tensors and returns the output tensors. The backward method, which computes gradients with respect to the input tensors, is automatically defined by PyTorch using the autograd package.
When a computation is performed in a neural network, PyTorch creates an instance of the corresponding Function class and calls its forward method. The output tensors returned by the forward method are associated with the grad_fn property, which allows PyTorch to trace the computation and compute gradients during the backward pass.
It is also worth noting that, by default, all tensors created by PyTorch have requires_grad=False, which means that gradients with respect to these tensors will not be computed during the backward pass. However, by setting requires_grad=True on a tensor, gradients will be computed, allowing the tensor to be used in the backward pass and allowing the user to update the model's parameters using the optimizer.

변화도 계산하기(Computing gradients)

신경망에서 매개변수의 가중치를 최적화하려면 매개변수에 대한 손실 함수의 도함수 계산 필요
이를 위해서는 x 및 y의 일부 고정 값에 대해 ∂loss/∂w 및 ∂loss/∂b 계산 필요
이러한 도함수를 계산하기 위해 loss.backward() 메서드가 호출됨
이후 w.grad 및 b.grad에서 값 검색 가능

loss.backward()
print(w.grad)
print(b.grad)

tensor([[0.2739, 0.0490, 0.3279],
        [0.2739, 0.0490, 0.3279],
        [0.2739, 0.0490, 0.3279],
        [0.2739, 0.0490, 0.3279],
        [0.2739, 0.0490, 0.3279]])
tensor([0.2739, 0.0490, 0.3279])

기울기(gradient, grad 속성)는 require_grad 속성이 True로 설정된 계산 그래프의 리프 노드에만 사용할 수 있음
그래프의 다른 노드에는 그라디언트를 사용할 수 없음
backward를 사용한 기울기 계산은 성능상의 이유로 지정된 그래프에서 한 번만 수행할 수 있음
동일한 그래프에서 여러 개의 backward 호출(calls)이 필요한 경우 retain_graph=True 매개변수를 backward 호출에 전달해야 함

키워드: ∂loss/∂w, ∂loss/∂b, loss.backward(), w.grad, b.grad, leaf nodes, root node, backward call, retain_graph=True

∂loss/∂w, ∂loss/∂b:
각각 weight 및 bias 변수에 대한 손실 함수의 편도함수(partial derivatives)
weight 또는 bias의 작은 변화(small change)에 대한 손실 함수의 변화를 나타냄
loss.backward():
PyTorch에서 손실 변수(loss variable)로 표시되는 계산의 입력 텐서에 대한 그래디언트를 계산하는 데 사용되는 메서드
loss variable의 grad_fn 속성과 연결된 Function 클래스의 backward 메서드로 계산된 그래디언트를 사용함
It uses the gradients computed by the backward method of the Function class associated with the grad_fn property of the loss variable.
w.grad, b.grad:
각각 weight 및 bias 변수의 기울기
역방향 패스 후 PyTorch에 의해 자동으로 계산됨
옵티마이저를 사용하여 가중치 및 편향 변수를 업데이트하는 데 사용할 수 있음
leaf node:
하위 노드가 없는 계산 그래프의 텐서
그래프에 대한 입력 텐서이며 일반적으로 require_grad=True를 가짐
root node:
backward pass가 시작되는 텐서
일반적으로 loss 텐서이며 forward pass의 마지막 연산
backward call:
backward() call은 루트 노드에서 시작하여 계산 그래프의 모든 텐서에 대한 그래디언트를 계산하는 데 사용됨
그래프를 역방향으로 탐색하고 미분의 연쇄 법칙(chain rule)을 사용하여 그래디언트를 계산
retain_graph=True:
backward() 메서드에 전달할 수 있는 선택적 매개변수
기본적으로 retain_graph=False는 백워드 패스 후에 그래프가 해제됨을 의미
retain_graph=True이면 그래프가 유지되고 다른 역방향 전달에 사용될 수 있음

변화도 추적 멈추기(Disabling gradient tracking)

기본적으로, require_grad=True인 텐서는 계산 기록을 추적하고 그래디언트 계산을 지원
학습된 모델을 입력 데이터에 적용만 하는 순전파 연산만 필요한 경우와 같이 추적 및 그래디언트 계산이 필요하지 않은 경우 존재
이러한 경우 코드를 torch.no_grad() 블록으로 둘러싸서 추적 중지할 수 있음
detach() 메소드도 동일하게 추적 중지할 수 있음

z = torch.matmul(x, w)+b
print(z.requires_grad)

with torch.no_grad():
    z = torch.matmul(x, w)+b
print(z.requires_grad)

z = torch.matmul(x, w)+b
z_det = z.detach()
print(z_det.requires_grad)

True
False
False

변화도 추적을 멈춰야 하는 이유들

신경망의 일부 매개변수를 고정으로 표시(frozen parameter)
이는 사전 훈련된 네트워크를 미세 조정하기 위한 일반적인 시나리오
그래디언트 추적이 없는 텐서에 대한 계산이 더 효율적이기 때문에 순방향 패스만 수행할 때 계산 속도 향상

Keywords: torch.no_grad() block, gradient tracking, frozen parameter, fine tuning

torch.no_grad() block:
그래디언트 추적을 일시적으로 비활성화하는 PyTorch에서 제공하는 컨텍스트 관리자
그래디언트 추적이 비활성화되면 포워드 패스가 평소와 같이 수행됨
그러나 그래디언트가 계산되지 않고 텐서의 grad 속성이 업데이트되지 않음
그래디언트가 필요하지 않을 때 계산 속도를 높이고 메모리를 절약하는 데 유용할 수 있음
gradient tracking:
backward pass 동안 모델의 매개변수와 관련하여 loss 함수의 기울기를 계산하고 저장하는 프로세스
PyTorch의 autograd 패키지에 의해 수행되며 requires_grad=True인 모든 텐서에 대해 기본적으로 활성화
frozen parameter:
기울기 추적이 비활성화된 매개변수
backward pass 중에 업데이트할 수 없음
require_grad=False를 설정하거나 매개변수를 torch.no_grad() 블록 내부에 배치하여 수행할 수 있음
fine tuning:
새로운 작업에 대해 사전 훈련된 모델을 훈련하거나 업데이트하는 프로세스
고정된 매개변수의 일부 또는 전부를 고정 해제하고 훈련 중에 업데이트하여 수행할 수 있음
사전 훈련된 모델이 새 작업에 유용한 기능을 학습했고 이 지식을 활용하여 성능을 향상시키려는 경우에 유용

연산 그래프에 대한 추가 정보(more on Computational Graphs)

autograd
- DAG에 데이터(텐서) 기록
- DAG에 실행된 모든 연산들(결과 텐서 생성 포함) 기록
- 방향성 비순환 그래프(DAG): Function 객체로 구성
  - 잎(leaves): 입력 텐서
  - 뿌리(root): 결과 텐서
  - 그래프 추적: 체인 규칙을 사용하여 변화도 자동 계산
- 순전파 단계(forward pass):
  - 요청된 연산 수행: 결과 텐서를 계산
  - 변화도 기능(gradient function): DAG에서 유지
- 역전파 단계(backward pass):
  - .backward()가 DAG 루트에서 호출될 때 시작
  - 변화도 계산: 각 .grad_fn에서
  - 변화도 누적(accumulate): 각 텐서의 .grad 속성에서
  - 전파(propagate): 체인 규칙을 사용하여 잎(leaf) 텐서까지
PyTorch의 DAG: 동적(dynamic)
- 그래프 재생성(recreate) 및 채움(populate): 각 .backward() 호출 후 처음부터
- 모델에서 제어 흐름(control flow) 문 허용됨
- 모양(shape), 크기(size), 연산(operation): 모든 반복(iteration)에서 변경될 수 있음

키워드: autograd, directed acyclic graph, chain rule, dynamic graph, allowing control flow statements, computation vs operation, cycle vs loop

Autograd:
텐서의 모든 작업에 대한 자동 미분를 제공하는 PyTorch 모듈
신경망의 backward pass 중에 변화도를 계산하는 데 사용되어 훈련 중에 변화도를 효율적으로 계산할 수 있음
Directed Acyclic Graph(DAG):
edge가 방향을 가져 방향이 있는 그래프를 형성하는 일종의 그래프 데이터 구조
cycle이나 loop가 없음
연쇄 법칙(chain rule):
합성 함수의 도함수는 구성 함수의 도함수를 곱하여 계산할 수 있다는 미적분학의 기본 개념
신경망에서 체인 규칙은 네트워크의 각 계층에 규칙을 반복적으로 적용하여 역방향 통과 중에 기울기를 계산하는 데 사용됨
동적 그래프(dynamic graph):
동적으로 변경될 수 있는 그래프
즉, 런타임 중에 그래프가 변경될 수 있음
더 많은 유연성을 허용하고 네트워크의 순방향 전달에서 루프 및 조건문과 같은 제어 흐름 문을 사용할 수 있게 함
제어 흐름 문 허용(allowing control flow statement):
Pytorch는 동적 그래프 기능을 사용하여 네트워크의 순방향 전달에서 제어 흐름 문을 사용할 수 있음
이를 통해 더 복잡한 신경망 아키텍처를 만들 수 있지만 계산 그래프가 더 복잡해지고 성능에 영향을 미칠 수 있음
computation vs operation:
computation은 최종 출력을 생성하기 위해 텐서에서 수행되는 sequence of operations
신경망에서의 layer 및 activation function 등을 통한 forward pass
operation은 행렬곱, non-linear activation function과 같은 computation의 단일 단계
cycle vs loop
cycle은 동일한 노드를 여러 번 방문할 수 있는 그래프의 닫힌 경로
loop는 특정 조건이 실행될 때까지 반복적으로 실행되는 일련의 명령
DAG 맥락에서 cycle은 동일한 노드로의 재방문을 의미, 비주기적이므로 DAG에서 허용되지 않음 -> Q) RNN에서는?
DAG 맥락에서 loop는 forward pass 중 발생하는 계산의 반복을 의미 -> Q) RNN에서는?

선택적으로 읽기: 텐서 변화도와 야코비안 곱(Optional Reading: Tensor gradients and jacobian products)

스칼라 손실 함수: 일부 매개변수에 대한 기울기
출력 함수가 임의의(arbitrary) 텐서인 경우 있음
PyTorch: Jacobian 곱 계산. 실제 gradient 아님
벡터 함수: y = f(x), 여기서 x = <x1, ..., xn> 및 y = <y1, ..., ym>
x에 대한 y의 기울기: Jacobian 행렬, Jij = ∂yi/∂xj
Jacobian 행렬: 직접 계산되지 않음
jacobian 곱: 주어진 입력 벡터 v = (v1 ... vm)에 대한 vT⋅J
backward 함수: v를 인수로 사용하여 호출
v의 크기(size): 곱을 계산하려고 하는 원래 텐서의 크기와 같아야 함

inp = torch.eye(5, requires_grad=True)
out = (inp+1).pow(2)
out.backward(torch.ones_like(inp), retain_graph=True)
print(f"First call\n{inp.grad}")
out.backward(torch.ones_like(inp), retain_graph=True)
print(f"\nSecond call\n{inp.grad}")
inp.grad.zero_()
out.backward(torch.ones_like(inp), retain_graph=True)
print(f"\nCall after zeroing gradients\n{inp.grad}")


tensor([[4., 2., 2., 2., 2.],
        [2., 4., 2., 2., 2.],
        [2., 2., 4., 2., 2.],
        [2., 2., 2., 4., 2.],
        [2., 2., 2., 2., 4.]])

Second call
tensor([[8., 4., 4., 4., 4.],
        [4., 8., 4., 4., 4.],
        [4., 4., 8., 4., 4.],
        [4., 4., 4., 8., 4.],
        [4., 4., 4., 4., 8.]])

Call after zeroing gradients
tensor([[4., 2., 2., 2., 2.],
        [2., 4., 2., 2., 2.],
        [2., 2., 4., 2., 2.],
        [2., 2., 2., 4., 2.],
        [2., 2., 2., 2., 4.]])

동일한 인자로 backward 두 차례 호출하면 변화도 값 달라짐
pytorch가 backward propagation 수행 시 변화도를 누적하기 때문에 발생
계산 그래프의 모든 리프 노드의 grad 속성에 더해짐
적절한 변화도 계산을 위해 grad 속성을 0으로 만들어야 함
옵티마이저: 실제 학습 시 grad 속성을 0으로 만드는 데 도와줌

backward() 함수: 위 코드에서 매개변수 없이 호출됨
backward(torch.tensor(1.0)) 호출과 동일
신경망 훈련 중 loss와 같은 스칼라 값 함수의 변화도 계산에 유용함
키워드: 역전파, Pytorch, 그래디언트, 누산, 옵티마이저, 스칼라 값 함수, 신경망 훈련.

Keywords: scalar loss function, Jacobian matrix, vector function, Jacobian product, shape vs size on tensor, scalar-valued function, optimizer

스칼라 손실 함수(Scalar Loss Function):
모델의 예측값과 정답값을 취하여 이들 사이의 불일치(discrepancy, 차이)를 측정 후 스칼라 값을 반환하는 함수
예) Mean Squared Error, Binary Cross-Entropy
모델의 예측 출력과 실제 출력 간의 차이를 최소화하여 신경망을 훈련하는 데 사용됨
자코비안 행렬(Jacobian matrix):
벡터 함수의 모든 1차 편미분 행렬
신경망에서는 모델의 매개변수에 대한 손실 함수의 기울기를 계산하는 데 사용됨
신경망의 역방향 통과 동안 기울기를 계산하는 데 사용되는 자동 미분의 기본 개념
벡터 함수(vector function):
하나 이상의 입력을 받아 벡터 출력을 반환하는 함수
신경망에서 모델의 정방향 전달(forward pass)은 입력이 벡터이고 출력도 벡터인 벡터 함수로 생각할 수 있음
자코비안 곱(Jacobian Product):
자코비안 행렬과 벡터의 곱
자코비안 행렬은 벡터 함수의 모든 1계 편도함수의 행렬
벡터는 그래디언트가 계산되는 방향
특정 방향의 입력에 대한 함수의 기울기를 계산하는 데 사용됨
Tensor의 모양 대 크기(shape vs size):
PyTorch에서 Tensor는 다차원 배열
텐서의 모양은 텐서의 각 차원의 크기를 나타내는 튜플
텐서의 크기는 모양의 곱인 텐서의 총 요소 수
예) 텐서의 모양이 (2,3)이라면 크기는 6
모양은 데이터의 구조를 이해하는 데 유용
크기는 데이터의 양을 이해하는 데 유용
스칼라 값 함수(scalar-valued function):
하나 이상의 입력을 받아 단일 스칼라 출력을 반환하는 함수
머신러닝에서 cost 또는 loss function을 나타내 신경망을 훈련하는 데 사용됨
옵티마이저(optimizer):
손실 함수와 같은 스칼라 값 함수를 최소화하기 위해 모델의 매개변수를 조정하는 데 사용되는 알고리즘
예) Stochastic Gradient Descent(SGD), Adam, Adagrad
learning rate 등의 자체 하이퍼 매개변수 세트 존재

대두코기

[Python] pyenv-win 설치 방법(PowerShell)

주니어 딥러닝 엔지니어 관점에서의 데이터 라벨링 교육 후기

IT 트렌드·동향 알려주는 정부·공공기관 사이트 모음

TL;DR

목차

서론

정부·공공기관의 정보를 봐야 하는 이유

관련 정부·공공기관 사이트 목록

과학기술정보통신부: 주간동향 - 과학기술정보통신부 (msit.go.kr)

한국인터넷진흥원: KISA 한국인터넷진흥원>지식플랫폼>동향분석>전체동향

한국지능정보사회진흥원: 한국지능정보사회진흥원 (nia.or.kr)

한국방송통신전파진흥원: 동향자료 | KCA 한국방송통신전파진흥원

한국정보통신기술협회: TTA저널 - TTA 대표홈페이지(국문)

정보통신기획평가원: 지식 > ICT 동향정보 | IITP

ITFIND(정보통신기획평가원(IITP) 정보서비스팀에서 개발한 ICT정보 종합검색시스템): ITFIND - Hot Issue

통계청: 뉴스기반통계검색서비스 (kostat.go.kr)

대한무역투자진흥공사: KOTRA 실리콘밸리 무역관 (kotrasvit.org)

[ChatGPT] 노코드 개발! ChatGPT로 크롬 익스텐션을 개발해보았다(1)

프로그램 및 알고리즘 구상

프로그램 관련 부분별 프로토타이핑

ChatGPT에게 역할 부여

복사-붙여넣기

디버깅 및 코드 수정

갤럽 강점 진단 싸게 하는 법(클리프턴 테스트, 스트렝스 파인더)

결과 미리보기

한화-원화 결제 금액 차이 : 8,960원

결과 보고서

순위가 같지만 다른 심층 결과

결제 진행 방법

1. 갤럽 강점 진단 링크에 들어간다.

2. 오른쪽 상단의 'SIGN IN'을 누른다.

3. '계정을 생성하십시오'를 누른다.

4. 정보를 입력하고 계정을 생성한다.

5. 추가 정보를 입력하고 설정을 완료한다.

6. 이메일로 전송된 인증 코드를 제출한다.

7. 로그인한다.

8. 왼쪽 위 메뉴에서 구매를 누른다.

9. 오른쪽 위 South Korea를 누른다.

10. 나라를 United States of America로 바꾼다.

11. 'Stay in the United States of America store'를 누른다.

12. 'LEARN MORE'를 누른다.

13. 'ADD TO CART'를 누른다.

14. 오른쪽 위 카트 모양을 누르고 'CHECKOUT'을 누른다.

15. 결제 창에서 원하는 수단을 선택한다.

16. 필요한 내용을 입력하고 'REVIEW ORDER'을 누른다.

17. 주소 확인이 안 될 때 - 'USE SELECTED'를 누른다.

18. 최종 정보 확인 후 'PLACE ORDER'을 누른다.

19. 'MANAGE MY DIGITAL REPORTS'를 누른다.

20. '코드 배포'를 누른다.

21. 배포할 번들을 선택하고 '다음'을 누른다.

22. 배포 방법에서 '이메일 코드'를 누른다.

23. 이메일 주소를 입력하고 언어를 'Korean'으로 선택하고 '저장'을 누른다.

24. 언어를 'Korean'으로 선택하고 '저장'을 누른다.

25. 내용을 확인 후 '이메일 코드'를 누른다.

26. 초대장이 보내진 것을 확인한다.

27. 해당 메일에서 '시작하기'를 눌러 테스트를 진행한다.

팁

[클라이밍] 클라이밍 전 필요한 스트레칭 정리

관절 돌리기 - 발목에서 목까지(링크)

상체 스트레칭(링크)

하체 스트레칭 - pt 선생님은 상체보다 하체 스트레칭이 어렵고 중요하고 오래 걸린다 하였음

폼롤러 마사지 - 부위 당 30~50번 추천

하체

상체

마무리 스트레칭 및 몸풀기 운동

[PyTorch] 공식 문서 Learn the Basics 요약 - 8. The full model building process 및 전체 요약

전체 모델 구축 프로세스(The full moel building process)

데이터 작업(Working with data)

모델 생성(Creating models)

모델 매개변수 최적화(Optimizing the Model Parameters)

모델 저장(Saving Models)

모델 불러오기(Loading Models)

요약(Summary)

[PyTorch] 공식 문서 Learn the Basics 요약 - 7. Save and load the model

모델 저장하고 불러오기(Save and load the model)

모델 가중치 저장하고 불러오기(Saving and Loading Model Weights)

모델 가중치를 불러오기 위해서는, 먼저 동일한 모델의 인스턴스(instance)를 생성한 다음에 load_state_dict() 메소드를 사용하여 매개변수들을 불러옵니다.

모델의 형태를 포함하여 저장하고 불러오기(Saving and Loading Models with Shapes)

모델 추론(Model Inference)