When will you grow up?

복잡한 딥러닝 논문, 짧은 코드로 구현하기

미카이 — Sun, 8 Dec 2024 23:55:38 +0900

딥러닝 연구를 하다 보면 최첨단 기술을 소개하는 논문들을 마주하게 됩니다. 하지만 이 논문들을 처음부터 끝까지 이해하고, 이를 코드로 구현하는 것은 상당히 많은 시간과 노력이 필요합니다. 이런 고민을 덜어줄 멋진 프로젝트가 있어 소개합니다: Papers-in-100-Lines-of-Code.

Papers-in-100-Lines-of-Code란?

이 프로젝트는 유명한 딥러닝 논문들을 단 100줄의 코드로 간결하게 재현하는 것을 목표로 합니다. 복잡한 알고리즘과 긴 코드 없이도 논문의 핵심 아이디어를 이해하고 재현할 수 있도록 설계된 코드를 제공합니다.
즉, 이 리포지토리는 딥러닝 연구자나 학습자에게 다음과 같은 이점을 제공합니다:

간결한 구현: 논문의 복잡한 내용을 최소한의 코드로 표현.
빠른 이해: 논문의 주요 아이디어를 빠르게 파악.
학습 도구: 논문의 구현 방법을 배우고 실습할 수 있는 좋은 예제.

가끔씩 보면서 구현 능력 키우면 좋을 것 같다.

[Error] torch.distributed.elastic.multiprocessing.errors.ChildFailedError 오류

미카이 — Sun, 8 Dec 2024 21:42:00 +0900

Multi-GPU Training 중 발생한 오류 해결 사례 공유

최근 Multi-GPU Training을 진행하던 중 아래와 같은 오류가 발생하여 학습이 중단되는 상황을 겪었습니다.

torch.distributed.elastic.multiprocessing.errors.ChildFailedError

이 오류를 해결하기 위해 다양한 방법을 시도해 보았고, 결국 마지막 방법으로 문제를 해결할 수 있었습니다. 이 글에서는 오류를 해결하기 위해 시도했던 과정과 해결 방법을 공유하고자 합니다.

1. 오류 발생 원인 추정

이 오류의 원인은 보통 다음과 같은 상황에서 발생할 수 있습니다:

RAM 부족
GPU Memory 부족
PyTorch 버전 문제
Batch Size 설정 문제

위 원인들을 하나씩 점검하며 해결 방법을 적용해 보았습니다.

2. 시도한 해결 방법

(1) shm(SHared Memory) 확장

Multi-GPU 환경에서 데이터를 로드하는 과정에서 공유 메모리 부족 문제가 발생할 수 있습니다. 이를 해결하기 위해 --shm-size 옵션을 사용하여 Docker 컨테이너의 공유 메모리를 확장했습니다.

docker run --shm-size=8g ...

그러나 이 방법만으로는 문제가 해결되지 않았습니다.

(2) PyTorch 버전 변경

사용 중이던 PyTorch 버전이 2.0.4였는데, 이를 최신 버전인 2.4.0으로 업데이트해 보았습니다. PyTorch는 버전 간 성능 최적화나 버그 픽스가 포함되므로, 이를 변경하면 문제가 해결되는 경우도 많습니다.

업데이트 명령은 다음과 같습니다:

pip install torch==2.4.0

하지만, 이 역시 제가 직면한 문제의 직접적인 원인을 해결하지는 못했습니다.

(3) Batch Size 조절

기본적으로 설정된 Batch Size는 128이었습니다. 이를 줄여서 GPU 메모리 사용량을 낮춰 보기로 했습니다. Batch Size를 64로 절반 줄인 후 다시 학습을 실행했더니, 오류 없이 학습이 진행되는 것을 확인했습니다.

코드별 다양한 예시가 있겠지만, 내 학습의 경우 batch_size를 다음과 같이 수정할 수 있었다.

train_loader = DataLoader(dataset, batch_size=64, shuffle=True)

이 글이 비슷한 문제를 겪고 있는 분들께 도움이 되길 바랍니다!

참고

https://discuss.huggingface.co/t/torch-distributed-elastic-multiprocessing-errors-childfailederror/28242

https://github.com/Vision-CAIR/MiniGPT-4/issues/237

[Monkey Patch] Pytorch 몽키패치 사용하기

미카이 — Mon, 2 Dec 2024 21:25:57 +0900

몽키패치(Monkey Patch)는 실행 중인 프로그램의 동작을 변경하기 위해 기존의 코드나 메소드를 동적으로 수정하거나 재정의하는 기법입니다. 파이썬에서는 클래스나 함수의 속성을 런타임에 변경할 수 있기 때문에 몽키패치가 자주 사용됩니다. PyTorch에서도 특정 기능을 커스터마이징하거나 디버깅, 실험적인 코드 변경 등을 위해 몽키패치를 활용할 수 있습니다.

몽키패치의 기본 원리

파이썬의 동적 속성 변경을 활용해 기존 모듈이나 클래스의 메서드를 재정의하거나 새로운 속성을 추가합니다. 아래는 간단한 예시입니다.

class MyClass:
    def original_method(self):
        print("Original Method")

# 기존 메서드를 변경
def monkey_patched_method(self):
    print("Monkey Patched Method")

MyClass.original_method = monkey_patched_method

# 실행
obj = MyClass()
obj.original_method()  # "Monkey Patched Method" 출력

PyTorch에서의 몽키패치 예시

1. torch.nn.Module의 Forward 메서드 패치

torch.nn.Module의 forward 메서드를 패치해 디버깅 메시지를 추가하거나 동작을 변경할 수 있습니다.

import torch
import torch.nn as nn

# 기존 모델 정의
class SimpleModel(nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.linear = nn.Linear(10, 1)
    
    def forward(self, x):
        return self.linear(x)

model = SimpleModel()

# 원래의 forward를 저장
original_forward = model.forward

# forward 메서드를 패치
def patched_forward(x):
    print("Input Tensor:", x)
    output = original_forward(x)
    print("Output Tensor:", output)
    return output

model.forward = patched_forward

# 실행
x = torch.randn(1, 10)
model(x)

2. Layer 패치로 특정 동작 변경

예를 들어, torch.nn.ReLU를 다른 활성화 함수로 대체할 수 있습니다.

import torch.nn.functional as F

# ReLU를 LeakyReLU로 패치
original_relu = nn.ReLU.forward

def patched_relu(self, input):
    print("ReLU is now LeakyReLU")
    return F.leaky_relu(input, negative_slope=0.1)

nn.ReLU.forward = patched_relu

# 모델 테스트
model = nn.Sequential(nn.Linear(10, 20), nn.ReLU())
x = torch.randn(1, 10)
output = model(x)

몽키패치를 사용할 때 주의할 점

코드 유지보수 어려움: 동작이 암묵적으로 변경되므로, 협업 환경에서 예기치 못한 버그를 초래할 수 있습니다.
안정성: PyTorch 업데이트 시 내부 구현이 변경되면 패치된 코드가 깨질 수 있습니다.
디버깅 난이도: 어디서 변경되었는지 추적하기 어렵습니다.

몽키패치를 대체할 안전한 방법

상속: 필요한 클래스나 메서드를 상속받아 수정.
커스터마이징: PyTorch 모듈과 기능은 높은 유연성을 제공하므로, 커스텀 구현을 고려.
함수 래핑: 기존 메서드를 감싸는 방식을 사용해 변경 내용을 분리.

몽키패치는 주로 빠른 프로토타이핑이나 실험에 유용하지만, 정식 코드에서는 신중하게 사용해야 합니다.

[이미지 생성 SOTA] red_panda? Recraft!

미카이 — Thu, 31 Oct 2024 23:36:50 +0900

최근에 FLUX 1.1[pro]를 제치고 새로운 강자로 떠오르는 이미지 생성모델이 나왔다.

출저 : https://artificialanalysis.ai/text-to-image

Text to Image Models and Providers Leaderboard | Artificial Analysis

Analysis of Text to Image AI models and providers across quality, generation time and price. Analysis to help you choose the best Text to Image model and provider for your use-case.

artificialanalysis.ai

처음에는 red_panda라고 NAME이 나와서 제조사나 모델도 알려지지 않은 상태였습니다.

Red Panda AI: 이미지 생성의 새로운 강자
최근 AI 이미지 생성 분야에 새로운 강자가 등장했습니다. 바로 'Red Panda AI'입니다. 이 혁신적인 모델은 현재 텍스트-이미지 생성 분야에서 놀라운 성과를 보이며 업계를 주도하고 있습니다.

압도적인 성능

Red Panda AI는 현재 72%라는 놀라운 승률을 기록하며, FLUX 1.1 Pro, Ideogram v2, Midjourney v6.1과 같은 유명 모델들을 능가하고 있습니다. 특히 최고의 경쟁자보다 40 Elo 높은 점수를 자랑하며, 그 우수성을 입증하고 있습니다.

뛰어난 품질과 일관성

Red Panda AI의 가장 큰 강점은 고품질 이미지 생성과 독특한 스타일의 일관성입니다. 이 모델은 시각적으로 멋진 이미지를 만드는 데 탁월하며, 매끄러운 스타일과 향상된 텍스트 정확도로 사실적인 비주얼과 복잡한 디자인을 구현해냅니다.

OpenAI와의 연관성?

업계에서는 Red Panda AI가 OpenAI의 최신 텍스트-이미지 모델일 가능성에 대해 추측하고 있습니다. OpenAI의 고급 일관성 모델 기술을 사용했다면, 이는 Red Panda AI의 뛰어난 속도와 품질을 설명할 수 있을 것입니다.

위와 같은 의문을 가지고 있었으며 그리고 이름도 판다로 되어있어서 중국회사로 처음엔 많이 유추되다가 Recraft로 밝혀졌습니다.

Recraft AI는 전문 디자이너들을 위한 프리미엄 AI 이미지 생성 및 편집 도구입니다. 이 플랫폼은 창의적인 작업 과정을 더욱 즐겁고 효율적으로 만들어주며, 무한한 디자인 가능성을 제공한다고 합니다.

recraft.ai

주요 기능 살펴보겠습니다.

AI 이미지 생성기: 사실적인 이미지부터 벡터 아트, 일러스트레이션까지 다양한 스타일 구현
AI 이미지 벡터화: 래스터 이미지를 고품질 벡터 그래픽으로 변환
목업 생성기: 디자인을 실제 제품에 적용한 모습을 쉽게 시각화
이미지 업스케일러: 저해상도 이미지를 고해상도로 개선
배경 제거 도구: 이미지에서 배경을 쉽게 제거
AI 지우개: 이미지의 특정 부분을 정교하게 제거 또는 수정

Recraft AI는 디자이너, 마케터, 기업가 등 다양한 분야의 전문가들에게 브랜드의 시각적 정체성을 높이는 매력적인 그래픽을 만들 수 있는 힘을 제공합니다. 무료 버전으로 시작할 수 있으며, 신용카드 등록없이도 바로 사용해볼 수 있습니다.

https://www.recraft.ai/

Infinite AI Artboard - Recraft

Premium image generation and editing tool. Store and share your own styles, create, fine-tune, upscale, and perfect your visuals.

www.recraft.ai

ref

https://redpandaai.net/

https://replicate.com/recraft-ai/recraft-v3

recraft-ai/recraft-v3 – Run with an API on Replicate

Pricing This model is priced by how many images are generated. Check out our docs for more information about how per-image pricing works on Replicate. Readme Overview Recraft introduces a revolutionary AI model that thinks in design language. This new mode

replicate.com

https://artificialanalysis.ai/text-to-image

Text to Image Models and Providers Leaderboard | Artificial Analysis

Analysis of Text to Image AI models and providers across quality, generation time and price. Analysis to help you choose the best Text to Image model and provider for your use-case.

artificialanalysis.ai

[SOTA OCR] GOT OCR-2.0

미카이 — Mon, 28 Oct 2024 22:57:49 +0900

GOT-OCR2.0은 광학 문자 인식(OCR) 분야에 새로운 AI 모델입니다. 이 모델은 기존 OCR 시스템의 한계를 극복하고 문서 처리 능력을 크게 향상시켰습니다.

OCR-2.0의 특징

- 엔드투엔드 모델: 복잡한 파이프라인 대신 통합된 아키텍처
- 낮은 학습 및 추론 비용: 합리적인 파라미터 수로 효율성 확보
- 다양성: 일반 텍스트뿐만 아니라 수식, 악보, 차트 등 다양한 시각적 "문자" 인식 가능

GOT-OCR2.0

일단, 그럼 한글 성능을 살펴보자

해당 내용은 나무위키 문서를 캡쳐했다.

입력

plain texts OCR mode 추론 결과

당연히, StepFun, Megvii Technology, University of Chinese Academy of Sciences, Tsinghua University 개발을 하였기에 한국어 데이터는 많이 학습 안된것으로 보인다. 하지만 이정도 결과도 상당한 것으로보이는데, Model Tuning을 하면 성능이 엄청 좋아질 것으로 보인다.

주요 기능은 다음과 같다.

- 다양한 입력 형식 지원 (사진, 문서 등)
- 포맷팅된 출력 생성 (마크다운, LaTeX 등)
- 영역 기반 인식, 동적 해상도 조정, 다중 페이지 OCR 등 고급 기능

또한, 위 그림을 살펴보면 Vision Transformer(ViT) 기반으로 인코더를 구축하고 디코더는 Qwen-0.5B 구축되어 8K 토큰의 긴 컨텍스트를 처리할 수 있다고 나온다. 일반 텍스트부터 복잡한 구조화된 데이터를 처리할 수 있는게 핵심이 아닐까 싶다.

GOT-OCR2.0은 OCR 기술의 새로운 방향을 오픈소스로 공개하고있습니다. 텍스트 인식의 정확도와 다양성을 크게 높임으로써, 정보 접근성과 분석의 새로운 가능성을 제시하고 있습니다.

해당 논문은 다음에서 읽어보는걸 추천한다.

https://arxiv.org/abs/2409.01704

General OCR Theory: Towards OCR-2.0 via a Unified End-to-end Model

Traditional OCR systems (OCR-1.0) are increasingly unable to meet people's usage due to the growing demand for intelligent processing of man-made optical characters. In this paper, we collectively refer to all artificial optical signals (e.g., plain texts,

arxiv.org

https://github.com/Ucas-HaoranWei/GOT-OCR2.0

GitHub - Ucas-HaoranWei/GOT-OCR2.0: Official code implementation of General OCR Theory: Towards OCR-2.0 via a Unified End-to-en

Official code implementation of General OCR Theory: Towards OCR-2.0 via a Unified End-to-end Model - Ucas-HaoranWei/GOT-OCR2.0

github.com

[2024 AI Index] Stanford AI Index

미카이 — Thu, 24 Oct 2024 23:55:35 +0900

매년 발생하는 스탠포 AI Index 보고서!!

보다보면, 현재 AI 트렌드 및 미래를 생각해볼 수 있다.

간략하게 요약해본다.

2024 AI Index 보고서는 인공지능의 사회적, 경제적 영향과 기술적 발전을 분석한 포괄적인 보고서입니다. 이번 보고서에서는 AI 훈련 비용 증가, 생성형 AI 투자 확대, 그리고 책임 있는 AI 개발의 필요성 등을 다룹니다.

주요 내용 요약:

1. 기술 성과: AI는 이미지 분류 등에서 인간을 능가하지만, 복잡한 문제 해결 능력은 여전히 부족합니다.
2. 모델 개발: 2023년 산업과 학계의 협력으로 다양한 머신러닝 모델이 탄생했습니다.
3. 훈련 비용: GPT-4 훈련에 약 7,800만 달러가 들었고, Google의 Gemini Ultra에는 1억 9,100만 달러가 투입됐습니다.
4. 책임 있는 AI: 표준화된 평가 기준이 없어 모델 위험성 비교가 어렵습니다.
5. 경제적 영향: 2023년 AI 민간 투자는 감소했지만, 생성형 AI 투자만큼은 급증했습니다.
6. 노동시장 변화: AI가 작업 효율을 높이지만, 감독 부족 시 성과가 악화될 위험이 있습니다.
7. 과학과 의학 분야의 활용: AI는 연구와 발견을 가속화하며, AlphaDev와 GNoME 같은 혁신적 도구들이 등장했습니다.

주요 표를 살펴보면

위 그림처럼, 2023년에 산업계는 51개의 주목할 만한 머신 러닝 모델을 만들어냈지만, Academia는 15개에 불과했다고 나오는데 역시.. 뭔가 산업계가 많은것을 주도하고 있는것이 사실인 것 같다.

또한, 위 표를 살펴보면 미국과 캐나다의 새로운 학사 학위 졸업생 수는 10년 이상 꾸준히 증가했지만, CS에서 대학원 교육을 선택하는 학생 수는 정체되었다고 나오는데 한국에 대입을 해보면 학생수가 폭발적으로 늘지않았나 생각이 든다.

마지막으로, 위 표를살펴보면 2022년에 AI 관련 직책은 미국 전체 구인 공고의 2.0%를 차지했지만, 이 수치는 2023년에 1.6%로 감소했습니다. AI 구인 공고의 감소는 선도적인 AI 기업의 공고 감소와 이러한 기업 내에서 기술 직무 비중 감소가 커지고 있는데 한국도 배우는 사람 등 수요와 공급이 맞지 않는 것같고 엄청난 과열이라고 생각이 든다.

투자 금액은 커지고 있는데 2023년 생성형 AI 투자 금액은 약 252억 달러로, 2022년에 비해 8배 이상 증가했다고 나오는데 이 말은.. 투자 금액은 커지는데 AI 개발자는 일자리는 줄어든다?? ㅠㅠ 회복하길 기대한다.

자세한 내용은 해당사이트에 방문해서 읽어보는걸 추천한다.

https://aiindex.stanford.edu/report/

AI Index Report 2024 – Artificial Intelligence Index

Welcome to the seventh edition of the AI Index report. The 2024 Index is our most comprehensive to date and arrives at an important moment when AI’s influence on society has never been more pronounced. This year, we have broadened our scope to more exten

aiindex.stanford.edu

[이미지 생성 SOTA] Stable Diffusion 3.5

미카이 — Wed, 23 Oct 2024 23:58:49 +0900

10월 22일, 이미지 생성 모델인 SD3.5 ( Stable Diffusion 3.5 ) 모델이 공개되었습니다.

Flux 모델이 대부분 사용되는 시점에 stability에서 모델을 발표해서 부라부라 사용후기 및 내용을 간략하게 포스팅을 하게되었다.

요약

Stable Diffusion 3.5는 Stability AI에서 새롭게 선보인 AI 기반 이미지 생성 기술로, 여러 모델 변형을 포함하고 있다. 주요 모델로는 Stable Diffusion 3.5 Large, Stable Diffusion 3.5 Large Turbo, 그리고 10월 29일에 출시 예정인 Stable Diffusion 3.5 Medium이 있는데 기대가 된다.

주요 특징 및 개선 사항

모델 변형:
- Stable Diffusion 3.5 Large: 80억 개의 파라미터를 가지고 있으며, 1메가픽셀 해상도에서 뛰어난 품질과 프롬프트 준수성을 제공하여 전문적인 사용에 적합하다고 한다.
- Stable Diffusion 3.5 Large Turbo: Large 모델의 증류 버전으로, 높은 품질의 이미지를 단 네 단계 만에 생성하며 속도가 매우 빠르다.
- Stable Diffusion 3.5 Medium: 10월 29일 출시 예정으로, 향상된 품질, 일관성 및 다중 해상도 생성 기능을 제공합니다.

- 맞춤화 및 접근성: 이 모델들은 매우 맞춤화 가능하며 소비자 하드웨어에서도 효율적으로 구동한다고 합니다. Stability AI 커뮤니티 라이선스 하에 상업적 및 비상업적 용도로 사용할 수 있습니다. 중요한건, Community, Enterprise License가 있는데 1M 달러 기준으로 나뉘는 것 같다. 자세한 내용은 여기를 살펴보자

- Diverse Outputs: 모델은 광범위한 스타일과 미학을 표현하는 이미지를 생성할 수 있으며, 이는 복잡한 프롬프트 없이도 가능하다고 한데 한번 표를 보면서 살펴보자.

레딧에 올라온 표를 살펴보면 Flux가 퀄리티면에서는 더 좋은데, SD3.5가 프롬프트 반영은 좀 더 좋은 것 같다.

출처 : https://www.reddit.com/media?url=https%3A%2F%2Fpreview.redd.it%2Fjust-experimented-a-little-with-sd-3-5-large-its-not-bad-v0-zoqqk9ws5cwd1.png%3Fwidth%3D2160%26format%3Dpng%26auto%3Dwebp%26s%3Dba1dfba2a9c9a2a5c4a6fc4ea4f86b43d8a50315

근데 아마도, 학습 이런 부분에 있어서는 SD 모델류를 따라올게 없어서 LoRA, Dreambooth 등 다양하게 사용될 것 같다.

Tutorial

https://stabilityai.notion.site/Stable-Diffusion-3-5-Large-Fine-tuning-Tutorial-11a61cdcd1968027a15bdbd7c40be8c6

Stable Diffusion 3.5 Large Fine-tuning Tutorial

Interested in generating images like this from SD3.5 Large?

stabilityai.notion.site

자세한 내용은 stability.ai 에서 확인가능합니다.

https://stability.ai/news/introducing-stable-diffusion-3-5

Flux보다 100배 빠른 Sana

미카이 — Thu, 17 Oct 2024 21:45:27 +0900

NVIDIA, MIT, Tsinghua University 연구진이 공동 연구한 Sana,

최대 4096 x 4096 해상도의 이미지를 효율적으로 생성할 수 있는 Text to Image 프레임워크??!

특히, 관심을 많이 가지고 있는 Flux 모델에 비해 100배 빠른 속도로 생성이 가능하고 16G GPU에서도 1024x1024 기준으로 1초 미만으로 이미지를 생성할 수 있다는점!

"번역"

Sana-0.6B 모델은 최신 대형 확산 모델(예: Flux-12B)과 비교해 20배 작은 크기로 100배 이상 빠른 처리량을 보여줍니다1
. 16GB 노트북 GPU에서 1024 × 1024 해상도 이미지를 1초 미만으로 생성할 수 있습니다

주요 특징은 다음과 같습니다.

- 깊은 압축 오토인코더: 기존 8배 압축에서 32배로 압축률을 높여 레이턴트 토큰 수를 대폭 줄였습니다
- 선형 DiT: 기존의 어텐션을 선형 어텐션으로 대체해 고해상도에서 효율성을 높였습니다
- 디코더 전용 텍스트 인코더: T5 대신 Gemma라는 소형 LLM을 사용해 텍스트 이해력을 향상시켰습니다
- 효율적인 학습 및 샘플링: Flow-DPM-Solver를 도입해 샘플링 단계를 줄이고 수렴 속도를 높였습니다

구조 및 latency 비교

해당 링크에서 추론 속도 영상도 보여지며 아직 소스 공개는 안되었지만 곧 나올것으로 보입니다.

https://nvlabs.github.io/Sana/

Sana

About Sana We introduce Sana, a text-to-image framework that can efficiently generate images up to 4096 × 4096 resolution. Sana can synthesize high-resolution, high-quality images with strong text-image alignment at a remarkably fast speed, deployable on

nvlabs.github.io

Paper

https://arxiv.org/abs/2410.10629

SANA: Efficient High-Resolution Image Synthesis with Linear Diffusion Transformers

We introduce Sana, a text-to-image framework that can efficiently generate images up to 4096$\times$4096 resolution. Sana can synthesize high-resolution, high-quality images with strong text-image alignment at a remarkably fast speed, deployable on laptop

arxiv.org

Object Detection SOTA 모델 Ultralytics YOLO11

미카이 — Mon, 30 Sep 2024 11:08:39 +0900

Yolo 모델이 벌써 11까지 나왔다.

Ultralytics에서 지원되는 yolo 모델을 보면 YOLOv3 ~ YOLOv11/ SAM,SAM2, FastSAM, YOLO-World까지 다양한 모델들을 지원한다.

아마 많은 사람들이 사용하는 이유중 하나는 간편하게 학습을 할 수 있고 지속적으로 코드 관리는 한다는 점이 있을 것이다.

성능을 살펴보면 기존의 YOLOv10보다 좋은것을 확인할 수 있다 mAP 기준

https://github.com/ultralytics/ultralytics

YOLO11의 주요 특징

향상된 성능: YOLOv8m 대비 22% 적은 매개변수로 더 높은 mAP 점수 달성
다양한 작업 지원: 객체 감지, 분류, 포즈 추정, 인스턴스 분할 등
개선된 아키텍처: 더 정확한 특징 추출과 처리 속도 향상
유연한 배포: 클라우드 및 엣지 디바이스 모두에 적합

예시코드

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.pt")

# Train the model
train_results = model.train(
    data="coco8.yaml",  # path to dataset YAML
    epochs=100,  # number of training epochs
    imgsz=640,  # training image size
    device="cpu",  # device to run on, i.e. device=0 or device=0,1,2,3 or device=cpu
)

# Evaluate model performance on the validation set
metrics = model.val()

# Perform object detection on an image
results = model("path/to/image.jpg")
results[0].show()

# Export the model to ONNX format
path = model.export(format="onnx")  # return path to exported mode

YOLO11은 컴퓨터 비전 분야에 새로운 가능성을 제시하며, AI 커뮤니티의 혁신을 이끌 것으로 기대됩니다. 정확성, 속도, 효율성을 결합한 이 모델은 실시간 애플리케이션에 특히 적합하며, 다양한 산업 분야에서 활용될 것으로 전망되며 자세한 내용은 YOLO Vision 컨퍼런스를 확인해보시면 좋을 것 같다.

https://www.ultralytics.com/ko/events/yolovision

YOLO 비전 2024

마드리드에서 열리는 YOLO VISION 2024에 참여하세요. 지금 바로 하이브리드 이벤트에 참가하여 비전 AI 분야의 리더 및 전문가들과 함께하세요.

www.ultralytics.com

참고자료

https://www.ultralytics.com/ko/events/yolovision

https://www.ultralytics.com/ko/blog/ultralytics-yolo11-has-arrived-redefine-whats-possible-in-ai

생성형 AI를 위한 컴퓨터 비전

미카이 — Sat, 14 Sep 2024 00:23:27 +0900

요즘 생성형 AI 관련된 내용일 정말 많이 올라오는데 특히, 자연어처리 와 더불어 LLM 관련된 내용이 정말 많이 올라오는데 반면 비전 관련된 책은 부족했다. 하지만 이렇게 비전관점에서 생성형 AI 책이 나오면서 많은 관심을 가질 수 있을 것 같다. 저자 서문에 따르면 비전 생성 모델에 대해 처음 공부할 때 도움이 될 기본 모델과 연구에서 대표적으로 활용되는 예시 모델의 전반적인 이론과 실습을 모두 다 잡는다고 나와있다. 실제로 목차와 내용을 살펴보니 간단한 배경지식 수학 내용부터 시작하여 GAN, Diffusion Based 모델까지 소개를 하고있다. 책 한권으로 모든 내용은 확인할 수 없겠지만 전반적인 개요와 사용법까지 익힐 수 있을것 같다. 제일 중요한 어디서부터 공부할 지 막막한 분들을 위해 정말 잘 집필한 책이다! 너무 강추한다. 생성형 관련된 컴퓨터 비전의 기초부터 최신 응용 모델까지 다루며, 수학적 수식과 이론을 기반으로 독자들에게 깊이 있는 이해를 제공한다.

이 책은 이러한 모델의 동작 원리와 수학적 기초를 상세히 설명하며, 다양한 응용 사례를 통해 독자들이 실질적으로 활용할 수 있도록 돕는다.

" ≪생성형 AI를 위한 컴퓨터 비전≫ 내부 서평단에 선정되어 책을 제공받아 작성된 서평입니다."

[Ubuntu] GPU 사용량 확인하는 다양한 방법

미카이 — Mon, 9 Sep 2024 23:02:11 +0900

딥러닝 등 다양하게 Nvidia GPU를 사용하다보면, GPU를 모니터링을 해야할 경우가 많은데, 여기서 다양한 방법을 소개합니다.

1. Python을 사용한 pynvml 라이브러리

pynvml은 NVIDIA Management Library (NVML) 인터페이스를 Python에서 사용할 수 있도록 하는 라이브러리입니다. 이를 통해 GPU 사용량을 코드로 확인할 수 있습니다.

# 설치
pip install nvidia-ml-py3

1.1 사용 예시

import pynvml

# NVML 초기화
pynvml.nvmlInit()

# GPU 장치 개수 확인
device_count = pynvml.nvmlDeviceGetCount()

for i in range(device_count):
    handle = pynvml.nvmlDeviceGetHandleByIndex(i)
    name = pynvml.nvmlDeviceGetName(handle)
    memory_info = pynvml.nvmlDeviceGetMemoryInfo(handle)
    utilization = pynvml.nvmlDeviceGetUtilizationRates(handle)
    
    print(f"GPU {i}: {name.decode('utf-8')}")
    print(f"Memory Total: {memory_info.total / 1024**2:.2f} MB")
    print(f"Memory Used: {memory_info.used / 1024**2:.2f} MB")
    print(f"Memory Free: {memory_info.free / 1024**2:.2f} MB")
    print(f"GPU Utilization: {utilization.gpu}%")
    print(f"Memory Utilization: {utilization.memory}%")
    print()

# NVML 종료
pynvml.nvmlShutdown()

pynvml 실행결과

2. gpustat CLI 툴

gpustat은 nvidia-smi 명령을 보다 보기 좋게 표시하는 도구입니다.

# 설치
pip install gpustat

2.2 사용 예시

gpustat -cp

gpu stat 결과

위 결과 ref : https://github.com/wookayin/gpustat

3. DCGM (Data Center GPU Manager)

DCGM은 NVIDIA에서 제공하는 GPU 모니터링 툴로, 특히 데이터 센터 환경에서 GPU를 관리하는 데 유용합니다.

설치 :

# 설치
sudo apt-get update \
    && sudo apt-get install -y datacenter-gpu-manager

4. TensorFlow 및 PyTorch를 통한 GPU 사용량 모니터링

TensorFlow 예시:

import tensorflow as tf

gpus = tf.config.experimental.list_physical_devices('GPU')
for gpu in gpus:
    print(f"GPU: {gpu}")
    details = tf.config.experimental.get_memory_info(gpu)
    print(f"Memory Free: {details['current']} bytes")
    print(f"Memory Allocated: {details['peak']} bytes")

PyTorch 예시:

import torch

if torch.cuda.is_available():
    print(f"Current GPU Memory Usage: {torch.cuda.memory_allocated()} bytes")
    print(f"Max GPU Memory Usage: {torch.cuda.max_memory_allocated()} bytes")
    print(f"Memory Reserved: {torch.cuda.memory_reserved()} bytes")

5. nvtop (NVIDIA GPU Top)

nvtop은 GPU 사용량을 실시간으로 모니터링할 수 있는 유틸리티입니다. CPU의 htop과 비슷하게 동작합니다.

설치:

# 설치
sudo apt install nvtop

사용:

nvtop

nvtop 실행예시

결론:

이 중에서 pynvml은 Python 코드로 GPU 상태를 직접 확인하고 싶을 때 유용하며, CLI 환경에서는 gpustat이나 nvtop을 추천드립니다.

GPU보다 20배 추론 속도를 가진 Cerebras

미카이 — Fri, 30 Aug 2024 14:12:50 +0900

요즘 gpu를 대체할 것이라는 얘기가 나오는 cerebras inference를 간단히 살펴보자.

CEO 겸 Co-Funder인 Andrew Feldman은 SeaMicro 회사 전 CEO였으며 초고밀도 컴퓨터 서버 산업 회사를 AMD에 엑싯한 경험을 가지고 있는 CEO이다.

https://cerebras.ai/

cerebras.ai 홈페이지를 들어가보면 다음과 같은 문구를 확인할 수 있다.

The world’s fastest inference.
20x faster than GPUs, 1/5 the cost.

Nvidia GPU보다 가격은 1/5 인데, 추론 속도는 20배 빠르다? 이건 못참지!

위 그림을 보면 Llama-3.1-8b 기준으로도 초당 1,837 토큰을 추론한다고한다. 어마어마하다.

과연 정말인지 TRY CHAT을 통해 사용해보자.

Llama3.1-70B 결과

위 이미지는 70b 기준으로도 정말 빠른 답변을 해주는것을 확인할 수 있다. 만약 GPT 계열 말고 Diffusion 계열도 지원한다고하면 정말 빠르게 이미지 생성, 동영상 생성하여 현업에서도 많이 도입될 수 있을거라 생각된다.

현재 지원되는 모델 리스트는 다음 Github에서 확인할 수 있다.

https://github.com/Cerebras/modelzoo

Visual Studio Code 유용 Extensions

미카이 — Thu, 29 Aug 2024 18:19:39 +0900

개발자를 위한 Visual Studio Code Extension 추천

Python으로 다양한 개발(deep learning, data analysis etc.)을 할 때 vscode를 이용하여 개발하는 경우가 많다. 내가 사용중인 유용한 Extension을 알아보자.

ex) Extension Tab -> Ctrl + Shift + X

1. Auto-Open Markdown Preview

Auto-Open Markdown Preview

Markdown을 작성할 때가 많은데 미리보기가 없으면 별도로 github, gitlab 등 다양한곳에 올려 확인해야 하는 번거로움이 있는데 Auto-Open Markdown Preview Extension을 설치하면 별도로 .md 파일을 수정하고 출력 결과를 확인할 수 있다.

https://github.com/imayobrown/DesignDocumentTemplates?tab=readme-ov-file#readme

Shift + Command + V로 눌러서 실행할 수 있다.

2. One Dark Pro

vscode 기본 테마가 맘에들지 않아 따로 테마를 설치하였다.

Atom의 상징적인 One Dark 테마이자, VS Code에 가장 많이 설치된 테마 중 하나이며 모드를 다양하게 선택할 수 있다.

https://marketplace.visualstudio.com/items?itemName=zivit.one-dark

설치 후 Set Color Theme를 누르게되면 적용된다.

3. Material Icon Theme

vscode explorer를 보게되면 아이콘이 너무 맘에안드는데, material icon theme를 적용하면 가독성 좋게 변경할 수 있다.

다양한 아이콘 테마는 여기서 확인할 수 있다.

적용 예시

4. Excalidraw

개발을 하다보면 플로우차트, 다이어그램, 시스템 설계도 등 그려야 할 경우가 많은데 다양한 툴이 있지만 vscode 안에서 사용할 수 있는 Excalidraw를 소개한다.

Excalidraw

extension을 설치 후 파일 확장자를 .excalidraw 만들면 그림판 느낌의 그릴 수 있는 화면이 띄워지고 png svg 다양한 포맷으로 뽑아낼 수 있다. 또한, 다양한 Library로 깔아서 아이콘을 사용할 수 있다.

test.excalidraw

그 외, 귀여운걸 원한다면 vscode-pets 를 설치해보자. 고양이가 등장한다.

Stable Diffusion 3.1 Coming Soon?

미카이 — Sat, 24 Aug 2024 00:08:32 +0900

Reddit에 재밌는 글이 있어서 포스팅,

https://www.reddit.com/r/StableDiffusion/comments/1exw2m4/sd_31_is_coming/?%24deep_link=true&correlation_id=21f2da84-8060-4063-8f6e-6241a1763d25&post_fullname=t3_1exw2m4&post_index=0&ref=email_digest&ref_campaign=email_digest&ref_source=email&utm_content=post_title&%243p=e_as&_branch_match_id=1285749299433919656&utm_medium=Email+Amazon+SES&_branch_referrer=H4sIAAAAAAAAA22P22oEIRBEv2byNjd1zRJYlkDIb4gZe2abeENbZj8%2FPdkkTwGF4pRVdt%2BIcn0ZxwLOIQ0258Fj%2FBxlvnZCyXwBY%2BsTy1Rww2i9acVfbkeqk6%2BdeOez7%2Fvwk19SYFD4VrIfHhyua6uYIhP2AkSqLGe47yKo45kzcjZYDbsYt6NQcudJKAeQzTFLJ9%2BoNOiEXlIp4C1xn0HHXMyrcPas%2BvOkp15NWvbnVUOvhZrt%2FKylEyfO5VTJrM37aAMcddL8TfAwMTq4szMxKLCygmDRG4cbVHpAs9iQLW7xf7emVhb49Rg2CrxVJN6Z6fc3hOThC8fXS7hzAQAA

요즘 이미지 생성 관련된 내용은 FLUX의 성능이 너무 좋아 Stable Diffusion3가 관심을 못받고 있었는데, Stable Diffusion3.1이 나온다는 소식이다.

과연 성능이 얼마나 나올지 나오면 바로 사용해서 테스트해보고 싶다..

올라보면 빠르게 테스트해서 포스팅 예정이다.

~~기술 발전 속도가 너무 빠르다..ㅠ~~

Hotshot : AI Video Generator

미카이 — Fri, 23 Aug 2024 15:34:51 +0900

hotshot logo

항상 웃고있는 Hotshot를 소개합니다.

Hotshot은 Text to Video Generation 할 수 있는 비디오 생성기입니다.

요즘 핫한 Luma AI, Kling AI 비디오 생성과 대응할 정도로 성능이 나오는 것 같습니다.

구글 아이디로 로그인하면 무료로 하루에 2개의 비디오를 생성할 수 있다고 나온다.

아마도 리소스 제한때매 생성횟수 limit을 걸어놓은게 아닐까 싶다.

무료버전이 아닌, Plus 버전을 사용한다면 달마다 99$로 생각보다 비싸게 받고있는 것 같다. 200개 횟수제한도 있는것으로 보인다. ㅠ_ㅠ

upgrade plan

Hotshot에서는 프롬프트 가이드를 제공하고 있고 간단하게 살펴보자.

Hotshot excels at creating videos of people, animals, and nature. (사람, 동물, 자연에 대한 영상을 만드는데 뛰어나다고 표현하고 있다. 아래는 다음과 같이 생성되면 자연스럽게 생성된다고 한다.)
For the best animal generations, we suggest prefixing animals with anthropomorphic like an anthropomorphic hippo is watching tv

그 외,

Styles

- Animation : pixar style, cute squirrel dressed in medival fashion, walking through medival village

- Paintings : fpv drone fly through exploding render of a painting by vincent van gogh impasto painting palate knife, thick paint on canvas a beautiful starry night sky

- Claymation : claymation style, anomalisa movie, A claymation woman in a red sweater smiles and poses for selfies, holding her phone with both hands, in a park with lush green grass. The lighting is soft and natural, enhancing the serene, casual atmosphere of the setting. The woman, with her hair styled in loose waves, exhibits expressions of delight and amusement as she engages with her reflection on the phone's screen. Claymation style

- Comic Book :

illustrated comic book art, vintage 50s comic book style, A young man with blonde hair, dressed in a blue shirt and dark pants, sits on a yellow couch in a living room, intensely playing handheld video games. His expression is focused and absorbed in the activity. The living room is decorated with plants on wooden stands, paintings on the wall, and a table with chairs visible in the background. The overall atmosphere suggests a leisurely, modern home setting. vintage 50s comic book style art

- Video Game: super mario in legend of zelda game, super mario is walking through hyrule, legend of zelda style graphics, ps5 high fidelity 3d graphics, cgi

다양한 스타일 형태로도 생성가능하다고 한다.

최종적으로 퇴근하는 직장인 영상을 만든 결과입니다.

다양하게 생성해보고 응용할 수 있고, AI 발전이 엄청 빠른것을 확인할 수 있다.

~~SORA 언제나오지..?~~

FLUX.1 Controlnet 사용하기

미카이 — Mon, 19 Aug 2024 17:41:29 +0900

요즘 핫한 FLUX 모델에 Controlnet 적용해보자.

실습은,

FLUX.1-dev 모델을 통해 이미지를 생성하고 생성된 이미지를 통해 Controlnet을 적용해볼 예정이다.

Docker를 이용하여 환경을 구축할 예정이다.

※ webui forge, comfyui 예제는 많이 보이지만 diffusers 형식으로 된 예제는 없길래 직접 만들어본다..

1. Install

# docker 실행
# nvidia에서 제공되는 24.05 기준으로 도커 컨테이너를 만들어 실습할 예정이다.
# mount는 위치는 자신에 알맞게 잘 셋팅한다 -v 자신폴더:/workspace
docker run --name flux --gpus "device=0" -it -v /mydisk:/workspace nvcr.io/nvidia/pytorch:24.05-py3

# 컨테이너 안
apt update -y
apt install -y python3-tk
pip install --upgrade pip

# flux repo 다운로드
git clone https://github.com/black-forest-labs/flux.git

# flux 경로 이동
cd flux

# 패키지 설치
pip install -e '.[all]'
pip install git+https://github.com/huggingface/diffusers.git
pip install accelerate
pip install opencv-python==4.8.0.74

여기까지 진행하면 필요 패키지는 다 설치됐을 것이다.

2. FLUX.1 [dev] 이미지 생성

여기서 dev 버전은 non-commercial license 이므로 상용화는 불가능하다.

여기서는 이것저것 테스트해볼 것이므로..

# flux_generation.py


import torch
from diffusers import FluxPipeline

model_id = "black-forest-labs/FLUX.1-dev" 

# 로컬 경로에 weight를 받을 예정이므로 cache_dir를 이용한다. 적절히 자신 경로에 맞게 수정하면 될 것이다.
pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", torch_dtype=torch.bfloat16, local_files_only=True, cache_dir='./weights/')
pipe.enable_model_cpu_offload() #save some VRAM by offloading the model to CPU. Remove this if you have enough GPU power

prompt = "A cat holding a sign that says hello world"
seed = 42
image = pipe(
    prompt,
    output_type="pil",
    num_inference_steps=4, #use a larger number if you are using [dev]
    generator=torch.Generator("cpu").manual_seed(seed)
).images[0]
image.save("flux_img.png")

flux_generation.py 파일을 만들고 위 코드를 넣은 후 python flux_generation.py 실행

그러면 현재 경로에 (/workspace/flux/) 에 flux_img.png 이미지가 저장되어 있을 것이다.

flux_img.png

생성된 결과 이미지를 보면 꽤 퀄리티가 좋을것을 볼 수 있다.

그럼 이 이미지를 Controlnet canny를 통해 강아지로 변경해보자.

3. Controlnet 적용

# canny_flux.py

import torch
from diffusers.utils import load_image
from diffusers.pipelines.flux.pipeline_flux_controlnet import FluxControlNetPipeline
from diffusers.models.controlnet_flux import FluxControlNetModel

# 여기서도 마찬가지로 weights 경로를 weights 폴더 안에 저장한다.
base_model = 'black-forest-labs/FLUX.1-dev'
controlnet_model = 'InstantX/FLUX.1-dev-Controlnet-Canny'
controlnet = FluxControlNetModel.from_pretrained(controlnet_model, torch_dtype=torch.bfloat16, local_files_only=True, cache_dir='./weights/')
pipe = FluxControlNetPipeline.from_pretrained(base_model, controlnet=controlnet, torch_dtype=torch.bfloat16, local_files_only=True, cache_dir='./weights/')
pipe.to("cuda")

control_image = load_image("./flux_img.png")
prompt = "A dog holding a sign that says hello world"
image = pipe(
    prompt, 
    control_image=control_image,
    controlnet_conditioning_scale=0.6,
    num_inference_steps=28, 
    guidance_scale=3.5,
).images[0]
image.save("flux_controlnet.jpg")

canny_flux.py 파일을 만들고 위 코드를 넣은 후 python canny_flux.py 실행

그러면 현재 경로에 (/workspace/flux/) 에 flux_controlnet.jpg 이미지가 저장되어 있을 것이다.

여기서 prompt를 확인해보면 다양하게 바꿔가면서 테스트해볼 수 있다.

canny가 적용된 결과를 살펴보자.

퀄리티가 꽤나 좋은것을 확인할 수 있다.

Ref.

https://huggingface.co/black-forest-labs/FLUX.1-dev

https://huggingface.co/InstantX/FLUX.1-dev-Controlnet-Canny

https://github.com/black-forest-labs/flux

Trapping Rain Water[leetcode 42]

미카이 — Sun, 18 Aug 2024 22:43:06 +0900

https://leetcode.com/problems/trapping-rain-water/description/

Problem.

각 막대의 너비가 1인 고도 지도를 나타내는 음이 아닌 정수 n이 주어지면 비가 내린 후 얼마나 많은 물을 가둘 수 있는지 계산해라

Input: height = [0,1,0,2,1,0,1,3,2,1,2,1]
Output: 6
Explanation: 위의 지도(검은색 부분)는 배열 [0,1,0,2,1,0,1,3,2,1,2,1]로 표시됩니다. 이 경우 빗물 6개(파란색 부분)가 갇혀 있습니다.

Solution.

이 문제를 해결하기 위해 "Two Pointers" 방법을 이용할 수 있다.

투 포인터는 배열에서 여러가지 쌍을 검색하는 데 일반적으로 사용된다. 만약 자세한 내용을 알고싶다면 geeks 내용을 살펴보자. https://www.geeksforgeeks.org/two-pointers-technique/

class Solution:
    def trap(self, height: List[int]) -> int:
        if not height:
            return 0
        
        left, right = 0, len(height) - 1
        left_max, right_max = 0, 0
        water = 0
        
        while left < right:
            if height[left] < height[right]:
                if height[left] >= left_max:
                    left_max = height[left]
                else:
                    water += left_max - height[left]
                left += 1
            else:
                if height[right] >= right_max:
                    right_max = height[right]
                else:
                    water += right_max - height[right]
                right -= 1
        
        return water

1. height가 비어있는지 확인하고 비어있다면 0을 반환.

2. 두 개의 포인터 left, right를 사용하며, left는 시작, right는 끝을 의미한다.

3. left_max와 right_max 변수를 통해 각각 왼쪽 및 오른쪽에서 최대 높이를 추적

4. water 변수를 사용해 총 물의 양 계산

5. left가 right보다 작은 동안 반복

- height[left] 가 height[right] 보다 작다면?

- height[left]가 left_max보다 크거나 같으면, left_max를 업데이트

- 아니라면, left_max - height[left]만큼의 물을 water에 더합니다.

- left를 1 증가시킵니다.

- height[right]가 height[left]보다 작거나 같다면?

- height[right]가 right_max보다 크거나 같으면, right_max를 업데이트

- 그렇지 않으면, right_max - height[right]만큼의 물을 water에 더합니다.

- right를 1 감소시킵니다.

6. water 반환

이 알고리즘은 O(n) 으로 동작하며 n는 height 리스트 길이

이미지 생성을 위한 FLUX.1

미카이 — Sat, 17 Aug 2024 23:55:42 +0900

요즘 가장 핫한 Flux를 Review해본다.

Flux는 blackforestlabs.ai 에서 개발된 모델이다.

모델은 총 3가지를 제공하고 있으며,

1. FLUX.1 [schnell]

- step 1~4 단계만으로도 고품질 이미지 생성가능

- 제일 중요한 apache-2.0 이므로 상업적 목적으로 사용가능

- 모델 weight 공개

- FLUX 모델 중 가장 빠르게 이미지 생성 가능

2. FLUX.1 [dev]

- 중간급 성능을 보여주며, FLUX.1 [pro] 와 버금가는 성능이라 나와있다.

- 학습시 guidance distillation 이용하면 효율성이 높아진다고 나와있다.

- 생성된 출력물은 https://huggingface.co/black-forest-labs/FLUX.1-dev/blob/main/LICENSE.md 라이센스를 참고하여 확인해보시면 좋을 것 같은데 연구 목적이 큰 것 같다.

- 모델 weight 공개

3. FLUX.1 [pro]

- 현재 가장 높은 성능을 보여주는 모델

- API 형태로 제공되며, 모델 공개는 안되어 있다

- 기업 전용 솔루션도 제공

- replicate 기준으로 가격을 살펴보면 $0.055 / image 수준이다.

Flux.1 Model Family

ref : https://blackforestlabs.ai/announcing-black-forest-labs/

Scaling Rectified Flow Transformers for High-Resolution Image Synthesis

Scaling Vision Transformers to 22 Billion Parameters

두 논문 기준으로 모델을 구성하고, 12B 파라미터를 가지고 있다고 한다.

또한,

RoFormer: Enhanced Transformer with Rotary Position Embedding

Scaling Vision Transformers to 22 Billion Parameters

이 두 논문 아이디어를 통합하여 모델 성능을 높이고 하드웨어 효율성을 개선했다고 한다.

정말 멋진 아이디어이다.

향 후 SOTA Text to Video 모델도 Up Next라고 하니 지켜보면 나올것 같다.

팔로업을 위해서는 X에서 팔로우하고 지켜보면 업데이트 내용을 확인할 수 있을 것이다.

https://x.com/bfl_ml

two-sum [leetcode 1]

미카이 — Thu, 15 Aug 2024 22:34:25 +0900

https://leetcode.com/problems/two-sum

리트코드 첫번째 문제이다.

첫번째 문제답게 난이도는 낮은편이고 그럼 문제를 살펴보도록 하자.

Example 1:

Input: nums = [2,7,11,15], target = 9
Output: [0,1]
Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].
Example 2:

Input: nums = [3,2,4], target = 6
Output: [1,2]
Example 3:

Input: nums = [3,3], target = 6
Output: [0,1]
 

Constraints:

2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
Only one valid answer exists.

입력으로 nums 리스트가 주어지고, 리스트 안에 숫자가 있는데 이 조합을 통해 target을 만드는 문제다.

제약조건을 살펴봐야하는데 리스트의 크기는 2 ~ 104 사이의 크기를 가지고 있고 오직 답은 1개만 나온다고 한다.

그래서 결국 최종적으로 리턴해야할 값은 리스트형태의 nums의 인덱스 위치다.

문제를 딱 보면 완전탐색(브루트포스) 형태로 모든것을 검색하면서 탐색할 수 있을거라 생각이 나서 바로 풀어봤다.

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        for i in range(len(nums)):
            for j in range(i+1, len(nums)):
                if nums[i] + nums[j] == target:
                    return [i,j]

0 1 2 3 이라는 인덱스가 있을때

0 1 -> 0 2 -> 0 3

1 2 -> 1 3

2 3

순서로 리스트를 순회하면서 확인하는 코드이다.

사실 보면 시간복잡도가 O^2이므로 속도면에서는 빠르지 않다.. 정확하게는 (0.5n^2) 정도가 되겠지만;

Dict 형태를 활용한다면 O(n)으로 시간복잡도를 줄일 수 있다.

실제로 실행해보면 가장 빠르게 동작할 수 있는 것을 확인해볼 수 있다.

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        num_dict = {}
        for i, num in enumerate(nums):
            complement = target - num
            if complement in num_dict:
                return [num_dict[complement], i]
            num_dict[num] = i
        return []  # 해답이 없는 경우 (문제 조건에 따르면 이 경우는 발생하지 않습니다)

간단하게 코드를 리뷰해보면

1. num_dict 빈 딕셔너를 생성하고

2. enumerate를 통해 num 인덱스 i를 가져오게 된다.

3. 현재 숫자 num와 합쳐 target이 될 수 있는 값을 complement로 계산한다.

4. complement 값이 num_dict 딕셔너리 안에 있는지 확인하고, 있다면 어떤 숫자와 현재 숫자가 합쳐져서 target이 될 수 있는 것을 의미한다.

5. 결국 complement가 num_dict에 있다면 complement 숫자의 인덱스와 현재 숫자의 인덱스를 반환하며 이게 return 된다.

ref

파이썬 알고리즘 인터뷰 (책)

Longest Palindromic Substring [leet code 5]

미카이 — Wed, 14 Aug 2024 00:04:18 +0900

https://leetcode.com/problems/longest-palindromic-substring/

팰린드롬 부분 문자열 문제다.

Palindromic 팰린드롬이 뭔지 알아보자.

Wiki 를 살펴보니 회문(回文) 또는 팰린드롬(palindrome)은 거꾸로 읽어도 제대로 읽는 것과 같은 문장이나 낱말, 숫자, 문자열(sequence of characters) 등이다. 보통 낱말 사이에 있는 띄어쓰기나 문장 부호는 무시한다라고 나와있다.

그럼 이제 문제를 살펴보자.

Example 1:

Input: s = "babad"
Output: "bab"
Explanation: "aba" is also a valid answer.
Example 2:

Input: s = "cbbd"
Output: "bb"
 

Constraints:

1 <= s.length <= 1000
s consist of only digits and English letters.

조건을 살펴보면 문자 s 의 길이는 1~1000사이로 주어지고, 문자안에 digits 숫자도 포함되는것을 볼 수 있다.

그럼 "asf11fa" 가있다면 "f11f" 도 팰린드롬이 될 수 있다.

어떻게 접근할 수 있을까?

내가 시도한 방식은 다음과 같다.

1. s의 길이가 2 미만이면 그대로 반환

2. 각 문자를 확인하면서 해당 문자를 중심으로 하는 홀수 길이 팰린드롬 확인

3. 각 문자를 확인하면서 해당 문자와 다음 문자 사이를 중심으로 하는 짝수 길이 팰린드롬 확인

4. 양쪽으로 확장하면서 팰린드롬 순회

5. 팰린드롬 길이가 이전에 찾은 최대 길이보다 길면 시작 위치와 길이 갱신

6. return

순으로 진행된다.

이 알고리즘의 시간 복잡도는 O(n^2)이라 통과 안될 줄 알았는데 생각보다 빠른 속도로 통과됐다.

class Solution:
    def longestPalindrome(self, s: str) -> str:
        if len(s) < 2:
            return s
        
        start = 0
        max_len = 1
        
        for i in range(len(s)):
            # 홀수 길이 팰린드롬 확인
            left, right = i, i
            while left >= 0 and right < len(s) and s[left] == s[right]:
                if right - left + 1 > max_len:
                    start = left
                    max_len = right - left + 1
                left -= 1
                right += 1
            
            # 짝수 길이 팰린드롬 확인
            left, right = i, i + 1
            while left >= 0 and right < len(s) and s[left] == s[right]:
                if right - left + 1 > max_len:
                    start = left
                    max_len = right - left + 1
                left -= 1
                right += 1
        
        return s[start:start + max_len]

Group Anagrams [leet code 49]

미카이 — Mon, 12 Aug 2024 23:36:29 +0900

https://leetcode.com/problems/group-anagrams/

애너그램 문제이며,

애너그램이란 문자열이 주어졌을 때, 알파벳의 나열 순서를 다르지만 그 구성이 일치하면 두 단어는 아나그램이라고 합니다.

ex) a = "atta" b = "taat" 일때 나열 순서는 다르지만 a 2개 t 2개로 a 와 b는 Anagram이라고 표현한다.

Example 1:

Input: strs = ["eat","tea","tan","ate","nat","bat"]
Output: [["bat"],["nat","tan"],["ate","eat","tea"]]
Example 2:

Input: strs = [""]
Output: [[""]]
Example 3:

Input: strs = ["a"]
Output: [["a"]]

문제는 strs 리스트 형태로 각 원소들이 str 형태가 주어지면 anagram 문자끼리 list로 묶어서 return하는 문제다.

다양하게 문제 풀이를 진행할 수 있으며, 여기서는 list 비교와 dict 형태로 두가지 풀이를 해볼 예정이다.

list방식으로 문자열을 비교하면 다음과 같이 풀이할 수있을 것이다.

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        # 결과를 저장할 리스트
        result = []
        # 이미 그룹화된 문자열들을 추적할 리스트
        seen = [False] * len(strs)
        
        for i in range(len(strs)):
            if seen[i]:
                continue
            # 현재 문자열을 포함할 새로운 그룹 생성
            group = [strs[i]]
            seen[i] = True
            # 나머지 문자열들과 비교
            for j in range(i + 1, len(strs)):
                if not seen[j] and sorted(strs[i]) == sorted(strs[j]):
                    group.append(strs[j])
                    seen[j] = True
            # 그룹을 결과 리스트에 추가
            result.append(group)
        
        return result

위 코드로 Run을 해보면 Testcase는 잘 통과하는 것을 볼 수 있겠지만, Submit를 하게되면 Time Limit Exceeded가 뜨는 것을 볼 수 있을 것이다.

왜?

Constraints:

1 <= strs.length <= 104
0 <= strs[i].length <= 100
strs[i] consists of lowercase English letters.

제약조건을 보면 str 길이가 길어지면 비교도 많아지고 이중포문을 돌며 리스트에 저장되면서 각 문자열을 다른 모든 문자열과 비교하기 때문인데, 다음과 같이 코드를 수정하면 느리지만 통과할 수 있다.

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        # 결과를 저장할 리스트
        result = []
        # 정렬된 문자열 리스트
        sorted_strs = []
        
        for s in strs:
            # 문자열을 정렬한 후 그 결과를 저장
            sorted_s = ''.join(sorted(s))
            
            # 정렬된 문자열이 이미 존재하는지 확인
            found = False
            for i in range(len(sorted_strs)):
                if sorted_strs[i] == sorted_s:
                    result[i].append(s)
                    found = True
                    break
            
            # 만약 새로운 아나그램 그룹이라면 새로 추가
            if not found:
                sorted_strs.append(sorted_s)
                result.append([s])
        
        return result

모든 문자열을 비교하던 것에 비해 효율적으로 비교하여시간 복잡도가 크게 줄어드는데, 사실 제일 간편하게 dict를 사용하면 삽입 삭제 등 비교하는게 시간 효율이 좋아질 것이다.

최종 코드는 다음과 같습니다.

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        # 아나그램 그룹을 저장할 딕셔너리 생성
        results = {}
        
        # 주어진 문자열 배열에서 각 문자열을 순회
        for s in strs:
            # 문자열을 정렬한 후 그 정렬된 문자열을 키로 사용
            sorted_str = ''.join(sorted(s))
            
            # 정렬된 문자열이 딕셔너리에 없다면 새 리스트 생성
            if sorted_str not in results:
                results[sorted_str] = []
            
            # 해당 리스트에 원래 문자열 추가
            results[sorted_str].append(s)
        
        # 아나그램 그룹들을 리스트로 반환
        return list(results.values())

AttributeError: module 'cv2.dnn' has no attribute 'DictValue'

미카이 — Mon, 12 Aug 2024 10:13:31 +0900

rembg import 시 다음과 같은 오류가 발생하였다.

from rembg import remove

ImportError 내용

ImportError: module 'cv2.dnn' has no attribute 'DictValue'

인터넷글을 찾아보니 다음과 같이 opencv 문제로 버전문제라고 버전을 바꾸라고 나와있다.

pip install opencv-python==4.8.0.74

하지만 위와 같이 버전을 바꿔도 오류가 지속적으로 발생하여 구글링을 해본 결과 다음과 같은 방법으로 해결할 수 있었다.

# 1. download the autofix tool
pip install opencv-fixer==0.2.5
# 2. execute
python -c "from opencv_fixer import AutoFix; AutoFix()"

해당 이슈는 다음 git issues에서 확인할 수 있다.

https://github.com/facebookresearch/nougat/issues/40

Most Common Word [leetcode 819]

미카이 — Sun, 11 Aug 2024 23:22:53 +0900

https://leetcode.com/problems/most-common-word/description/

가장 흔한 단어

1. 처음 풀이법

- 소문자 변경

- 구두점 제거 및 단어 분리

- 단어 빈도수 계산

- 가장 빈번한 단어 찾기

순서로 간단하게 해결하였다.

처음 풀이한 코드는 다음과 같다.

from typing import List

class Solution:
    def mostCommonWord(self, paragraph: str, banned: List[str]) -> str:
        # 소문자로 변환
        paragraph = paragraph.lower()
        
        # 구두점 제거 및 단어 분리
        words = []
        current_word = ""
        for char in paragraph:
            if char.isalpha():
                current_word += char
            else:
                if current_word:
                    words.append(current_word)
                    current_word = ""
        if current_word:  # 마지막 단어 추가
            words.append(current_word)
        
        # 단어 빈도수 계산
        word_count = {}
        for word in words:
            if word not in banned:
                word_count[word] = word_count.get(word, 0) + 1
        
        # 가장 빈번한 단어 찾기
        max_count = 0
        most_common = ""
        for word, count in word_count.items():
            if count > max_count:
                max_count = count
                most_common = word
        
        return most_common

하지만 생각해보니, 정규표현식으로 간단하게 풀이할 수 있었다.

import re
from typing import List

class Solution:
    def mostCommonWord(self, paragraph: str, banned: List[str]) -> str:
        # 소문자로 변환하고 알파벳이 아닌 문자를 공백으로 대체
        paragraph = re.sub(r'[^a-zA-Z]', ' ', paragraph.lower())
        
        # 단어로 분리
        words = paragraph.split()
        
        # 단어 빈도수 계산
        word_count = {}
        for word in words:
            if word not in banned:
                word_count[word] = word_count.get(word, 0) + 1
        
        # 가장 빈번한 단어 찾기
        return max(word_count, key=word_count.get)

두개 속도를 비교해보면 처음 순서대로 풀이한게 속도 측면은 더 빨랐으며, 아래 풀이는 간편하게 풀이할 수 있다.

아마 코테를 보게된다면 정규표현식은 생각못하고 첫번째 방법으로 풀이할 것 같다.

FastHTML 소개

미카이 — Sun, 11 Aug 2024 19:22:50 +0900

FastHTML

FastHTML은 Python으로 웹 애플리케이션을 만들고 몇 분 안에 배포할 수 있는 웹 프로그래밍 시스템입니다. 목표는 빠른 프로토타입을 만드는 가장 쉬운 방법과 확장 및 축소가 가능하다.

또한, Railway, Vercel 등 다양한 호스팅 서비스에서 쉽게 배포가 가능하며 React, Next.JS와 비슷한 프레임워크와 비교했을 때 속도와 사용성 면에서 경쟁력이 있다 주장하고 있다.

설치

pip install python-fasthtml

사용법

# main.py
from fasthtml.common import *

app,rt = fast_app()

@rt('/')
def get(): return Div(P('Hello World!'), hx_get="/change")

serve()

실행

python main.py # 웹 브라우저 -> http://localhost:5001

위 사용 실행법을 보면, 실제로 너무 간편하게 web에서 실행할 수있고, 실행중에 코드 수정하면 지속적으로 바뀌면서 반영된다. 약간 FastAPI과 비슷한 구조로 되어있는데 실제로 저자가 말하기로는 Backend를 FastAPI를 사용하면 빠르게 개발할 수 있다고 나와있다.

시간날때마다 지속적으로 FastHTML을 가지고 다양한 것을 만들어 볼 예정이다.

실제 전설적인 Python Coder이자 Django의 공동저자인 Audrey Roy Greenfeld는 다음과 같이 얘기하였습니다.

“I think the fact that an experienced web dev can get productive in 1 hour accidentally undersells FastHTML a bit. For me it is like a fractal where the more I explore, the more interesting is and the more I learn. I’m about 40 hours in, enough to realise I know nothing compared with what I can learn.“

"숙련된 웹 개발자가 1시간 만에 생산성을 높일 수 있다는 사실이 FastHTML을 과소평가하는 것 같아요. 제게는 탐구할수록 더 흥미롭고 더 많은 것을 배울 수 있는 프랙탈과도 같습니다. 약 40시간이 지나니 배울 수 있는 것에 비해 제가 아는 것이 아무것도 없다는 것을 깨달을 정도입니다."

Ref.

https://docs.fastht.ml/

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

BardAPI를 이용한 ChatBot 만들기

미카이 — Thu, 1 Jun 2023 17:56:54 +0900

이번에는 요즘 ChatGPT와 대립하여 많은 분들이 사용중인 Google에서 만든 BardAPI+Streamlit를 이용하여 ChatBot을 구현해보겠습니다.

Bard를 이용한 ChatBot 예시

Linux 환경 & Window 환경 둘 다 상관없이 잘 돌아가는 것을 확인했다.

1. 필요 Package 설치

pip install streamlit
pip install streamlit-chat
pip install bardapi

2. BardAPI 발급받기

주의사항 : 쿠키값(Cookie Value)이 주기적으로 변할 수 있으니 값을 항상 확인해주자

크롬 브라우저에서 https://bard.google.com/ 방문하기
F12를 눌러 console 창 띄우기
Application -> Cookies -> __Secure-1PSID 값 복사하기

3. 복사한 값 os.environ['_BARD_API_KEY']에 넣기

- 아래 코드를 streamlit_bard.py 로 저장

# streamlit_bard.py 


import streamlit as st
from streamlit_chat import message
import requests
from bardapi import Bard
import os
import bardapi
os.environ['_BARD_API_KEY']="Insert the copied value here" # 저장한 값 변경


st.header(" ‍ Bard ChatBot ‍ ")
st.markdown("[Demo Site](boysboy3.tistory.com)")

if 'generated' not in st.session_state:
    st.session_state['generated'] = []

if 'past' not in st.session_state:
    st.session_state['past'] = []



with st.form('form', clear_on_submit=False):
    user_input = st.text_input('You: ', '', key='input')
    submitted = st.form_submit_button('Send')

if submitted or user_input:
    response = bardapi.core.Bard().get_answer(user_input)

    st.session_state.past.append(user_input)
    st.session_state.generated.append(response['content'])

if st.session_state['generated']:
    for i in range(len(st.session_state['generated'])-1, -1, -1):
        message(st.session_state['past'][i], is_user=True, key=str(i) + '_user')
        message(st.session_state["generated"][i], key=str(i))

4. 실행

아래 명령어를 cmd를 통해 실행 시킨 후 http://localhost:8501/로 접속 가능

streamlit run streamlit_bard.py

* Reference

https://github.com/dsdanielpark/Bard-API

https://github.com/AI-Yash/st-chat

졸업생 감동시킨 필즈상 허준이 교수님의 서울대 졸업식 축사

미카이 — Thu, 1 Sep 2022 14:44:02 +0900

'''

안녕하세요, 07년도 여름에 졸업한 수학자 허준이입니다.

우리가 팔십 년을 건강하게 산다고 가정하면 약 삼만일을 사는 셈인데, 우리 직관이 다루기엔 제법 큰 수입니다. 저는 대략 그 절반을 지나 보냈고, 여러분 대부분은 약 삼 분의 일을 지나 보냈습니다. 혹시 그중 며칠을 기억하고 있는지 세어 본 적 있으신가요? 쉼 없이 들이쉬고 내쉬는 우리가 오랫동안 잡고 있을 날들은 삼만의 아주 일부입니다. 먼 옛날의 나와, 지금 여기의 나와, 먼 훗날의 나라는 세 명의 완벽히 낯선 사람들을 이런 날들이 엉성하게 이어 주고 있습니다. 마무리 짓고 새롭게 시작하는 오늘 졸업식이 그런 날 중 하나일 수 있겠다는 생각이 듭니다. 그런 하루를 여러분과 공유할 수 있어서 무척 기쁩니다.

학위수여식에 참석할 때 감수해야 할 위험 중 하나가 졸업 축사가 아닌가 합니다. 우연과 의지와 기질이 기막히게 정렬돼서 크게 성공한 사람의 교묘한 자기 자랑을 듣고 말 확률이 있기 때문입니다. 저는 겁이 나서, 아니면 충실하게 지내지 못한 대학생활이 부끄러워 십오 년 전 이 자리에 오지 못했습니다만, 여러분은 축하받을 만한 일을 축하받기 위해 이를 무릅쓰고 이곳에 왔습니다.

졸업식 축사에서는 어떤 이야기를 하면 좋을까요? 십몇 년 후의 내가 되어 자신에게 해줄 축사를 미리 떠올려 보는 것도, 그 사람에게 듣고 싶은 축사를 지금 떠올려 보는 것도 가치 있지 않을까 싶습니다. 생각해 보세요. 당연하게 떠오르는 말은 없습니다. 지난 몇천 일, 혹은 다가올 몇천 일간의 온갖 기대와 실망, 친절과 부조리, 행운과 불행, 그새 무섭도록 반복적인 일상의 세부 사항은 말하기에도, 듣기에도 힘들거니와 격려와 축하라는 본래의 목적에도 어울리지 않을 것입니다. 구체화한 마음은 부적절하거나 초라합니다.

제 대학생활은 잘 포장해서 이야기해도 길 잃음의 연속이었습니다. 똑똑하면서 건강하고 성실하기까지 한 주위 수많은 친구를 보면서 나 같은 사람은 뭘 하며 살아야 하나 고민했습니다. 잘 쉬고 돌아오라던 어느 은사님의 말씀이, 듬성듬성해진 성적표 위에서 아직도 저를 쳐다보고 있는 듯합니다. 지금 듣고 계신 분들도 정도의 차이와 방향의 다름이 있을지언정 지난 몇 년간 본질적으로 비슷한 과정을 거쳤으리라 생각합니다. 그리고 이제 더 큰 도전, 불확실하고, 불투명하고, 끝은 있지만 잘 보이진 않는 매일의 반복을 눈앞에 두고 있습니다. 생각보다 힘들 수도, 생각만큼 힘들 수도 있습니다.

이제 본격적으로 어른입니다. 실패를 두려워하지 말고 도전하라. 편안하고 안전한 길을 거부하라. 타협하지 말고 자신의 진짜 꿈을 좇아라. 모두 좋은 조언이고 사회의 입장에서는 특히나 유용한 말입니다만, 개인의 입장은 다를 수 있음을 여러분은 이미 고민해 봤습니다. 제로섬 상대평가의 몇 가지 퉁명스러운 기준을 따른다면, 일부만이 예외적으로 성공할 것입니다. 여러 변덕스러운 우연이, 지쳐버린 타인이, 그리고 누구보다 자신이 자신에게 모질게 굴 수 있으니 마음 단단히 먹기 바랍니다. 나는 커서 어떻게 살까, 오래된 질문을 오늘부터의 매일이 대답해줍니다. 취업 준비, 결혼 준비, 육아 교육 승진 은퇴 노후 준비를 거쳐 어디 병원 그럴듯한 일인실에서 사망하기 위한 준비에 산만해지지 않기를 바랍니다. 무례와 혐오와 경쟁과 분열과 비교와 나태와 허무의 달콤함에 길들지 말길, 의미와 무의미의 온갖 폭력을 이겨내고 하루하루를 온전히 경험하길, 그 끝에서 오래 기다리고 있는 낯선 나를 아무 아쉬움 없이 맞이하길 바랍니다.

오래전의 제가 졸업식에 왔다면 무슨 이야기를 해줘야 할까 고민했습니다만 생각을 매듭짓지 못했습니다. 그가 경험하게 될 날들이 안쓰럽기도 하고 가슴 먹먹하게 부럽기도 합니다. 여러분은 자신에게 선물할 어떤 축사를 떠올리셨을지 궁금합니다.

수학은 무모순이 용납하는 어떤 정의도 허락합니다. 수학자들 주요 업무가 그중 무엇을 쓸지 선택하는 것인데, 언어를 어떻게 사용할 것인가에 대한 가능한 여러 가지 약속 중 무엇이 가장 아름다운 구조를 끌어내는지가 그 가치의 잣대가 됩니다. 오늘같이 특별한 날 특별한 곳에서 특별한 사람들과 함께하니 들뜬 마음에 모든 시도가 소중해 보입니다.

타인을 내가 아직 기억하지 못하는 먼 미래의 자신으로, 자신을 잠시지만 지금 여기서 온전히 함께하고 있는 타인으로 받아들일 수 있을까 궁금해집니다. 졸업생 여러분, 오래 준비한 완성을 축하하고, 오늘의 새로운 시작을 축하합니다. 서로에게, 그리고 자신에게 친절하시길, 그리고 그 친절을 먼 미래의 우리에게 잘 전달해 주길 바랍니다. 응원합니다. 축하합니다. 감사합니다.

'''

서울대 졸업생이 아니지만 너무 좋은말이네요..말에서도 내공이 느껴지는...

파이썬 시퀀스(python sequence)_05

미카이 — Tue, 22 Mar 2022 15:16:47 +0900

시퀀스(sequence) 타입이란 순서가 있는 데이터 집합인데, 파이썬에서는 대표적으로 리스트(list)가 있다.

그 중, 수정 가능한 mutable(가변)형 및 수정 불가능한 immutable(불변)형이 있다.

mutable(list, bytearray, array.array, memoryview, deque etc..)

immutable(tuple, str, bytes etc..)

또한, 파이썬에서는 크게 2가지 종류의 데이터 타입으로 나뉜다.

컨테이너(container:서로 다른 자료형 담을 수 있는 데이터 타입) -> list, tuple, collections.deque etc...

플랫(flat: 한개의 자료형만 담을 수 있는 데이터 타입) -> str, bytes, bytearray, array.array, memoryview etc...

그렇다면 이제 리스트 심화? 파이써닉하게 리스트를 만드는 방법을 알아보자.

다음 예제는 문자 -> 유니코드로 변환 하고 다시 유니코드 -> 문자로 변경하는 실습을 해보자.

1
2
3
4
5
6
7

chars = '+_)(*&^%$#@!'
# str는 불변이라 chars[2] = 's' 이렇게 변경 불가! 왜냐면 불변형이기 때문에!
 
code_list1 = []
for s in chars:
   code_list1.append(ord(s)) # ord() 문자를 유니코드로 변경
print(code_list1)
Colored by Color Scripter

cs

만약 우리가 리스트를 이용해 작성했다고 가정 하면 위와 같이 작성했을 것이다.

하지만 속도면에서도 훨씬 빠른 list comprehending을 이용하면 쉽고 빠르게 작성할 수 있다.

1

code_list2 = [ord(s) for s in chars] # 한줄로도 이렇게 표현 가능하다.

cs

다시 유니코드로 돌리려면 chr() 메소드를 이용하면 다시 돌릴 수 있다.

1
2
3
4
5

code_list3 = [ord(s) for s in chars if ord(s) > 40]
print(code_list3)
code_list4 = list(filter(lambda x : x > 40, map(ord, chars)))
print(code_list4)
print([chr(s) for s in code_list1]) # ord 반대로 / 유니코드를 문자로 바꿔줌

cs

마지막으로 리스트 사용시 주의할 점을 알아보자.

깊은 복사(deep copy), 얕은 복사(shallow copy)

깊은 복사는 새로운 소주에 값을 할당하여 값을 변경 해도 다른 객체이기 때문에 변경하면 이전 객체는 변경되지 않는 반면, 얕은 복사는 값을 수정하면 값이 참조하고있기에 변경된다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

marks1 = [['~'] * 3 for _ in range(4)]
print(marks1)
 
marks2 = [['~']*3] * 4  # 이렇게 만들어도 결과는 똑같지만, 수정시 문제가 된다
print(marks2)
 
# 수정
marks1[0][1] = 'X'
marks2[0][1] = 'X'
print(marks1)
print(marks2) # 이렇게 수정하면 각 리스트별 2번째 원소가 다 바뀐다. [['~', 'X', '~'], ['~', 'X', '~'], ['~', 'X', '~'], ['~', 'X', '~']]
 
# 왜 이런일이 일어났나면 첫번째(marks1)는 정확하게 다 복사가 됐기 때문에 모두 다 다른 주소를 가지고있는 반면,
# 두번째(marks2)는 하나의 주소값이 4개가 복사가 됐기 때문에 수정이 이뤄난다.
 
# 증명
print([id(i) for i in marks1]) # 주소가 다 다른 반면
print([id(i) for i in marks2]) # 주소가 동일..
Colored by Color Scripter

cs

우리를 위한 프로그래밍 : 파이썬 중급 를 기반으로 정리하였으며,

기본적인 내용보다는 실질적으로 Why? 라는 의문이 가질 법한 내용 위주로 정리하였습니다.

Magic method(special method)_04

미카이 — Tue, 22 Mar 2022 09:04:29 +0900

이번에는 매직메소드를 알아보자.

파이썬 공식 도큐먼트(https://docs.python.org/3/reference/datamodel.html) 에는 special method라고 소개하고 있지만 상황에따라 매직메소드==스페셜메소드 동일하게 부르니 헷갈리지 말자.

매직 메소드(magic method)란?

클래스안에 정의할 수 있는 특정한(built-in) 메소드다.

그렇다면 built-in은 무엇인가? 내장 함수라고해서 import 과정을 필요로 하지 않는 함수들을 말한다.

ex) abs(), chr(),divmod() etc...

우리가 일반적으로 변수를 선언하고 10을 더하는 코드를 작성한다고 가정하자.

1
2
3

n = 10
print(n+10)
print(type(n))  # int형 이지만 class 형식으로 나온다 

cs

위와 같이 작성할 것이다.

여기서보면 내부적으로 int형 class의 add형 메소드가 실행되었다고 나올 것이다.

그렇다면 다음과 같이 변경해도 결과는 어떻게 나올까?

1
2
3
4

print(n.__add__(100)) # 같은 결과가 나온다
# print(n.__doc__) # 클래스 맨 위 """""" 형으로 감싸져있는 값이 나온다..
print(n.__bool__(), bool(n)) # True 내부적으로 __bool__이 실행된다
print(n * 100, n.__mul__(100))

cs

동일한 결과를 얻을 수 있을것이다.

결국 built-in이기 때문에 우리가 쉽게 사용할 수 있는 것이다.

이것을 매직 메소드(스페셜 메소드)라고 부르는 이유이다.

이제 클래스를 하나 만들고 안에서 매직 메소드를 재정의하여 사용해보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

class Fruit(object):
    def __init__(self, name, price):
        self._name = name
        self._price = price
 
    def __str__(self):
        return 'Fruit Class Info : {} , {}'.format(self._name, self._price)
 
    def __add__(self, x): # 내부적으로 class INT(object): 이런 느낌으로 클래스가 존재해서 만들어준다 ?
        #print('called __add__')
        return self._price + x._price
 
    def __sub__(self, x):
        #print('called __sub__')
        return self._price - x._price
 
    def __le__(self, x): # 대소 비교
        print('called __le__')
        if self._price <= x._price:
            return True
        else:
            return False
 
    def __ge__(self, x): # 대소 비교
        print('called __ge__')
        if self._price >= x._price:
            return True
        else:
            return False

# 인스턴스 생성
s1 = Fruit('Orange', 7500)
s2 = Fruit('Banana', 3000)
Colored by Color Scripter

cs

위와 같이 과일의 이름과 가격을 담을 클래스를 만들고 Orange, Banana 두 가지 인스턴스를 만든다.

덧셈(__add__), 뺄셈(__sub__), 대소(__le__, __ge__) 비교 함수를 재 정의한다.

각 인스턴스 별 가격을 연산하는 방법을 알아보자.

만약 매직 메소드를 모른다면 아래와 같이 연산할 것이다.

1

print(s1._price + s2._price) # 이렇게 접근하면 좋지않고, 코드양도 엄청 늘어나고 가독성도 떨어진다.

cs

매직 메소드를 이용한다면?

1
2
3
4

print(s1 + s2) # 이렇게 계산하면 __add__ 메소드만 바꾸면 모든지 다 바꿔서 효율을 엄청 올릴 수 있다.
print(s1 - s2) # 이렇게 계산하면 __sub__에서 x 인자값에 s2가 바로 넘어간다. 또한, 인자값을 무궁무진하게 넣을 수 있다. (self, x, y.....)
print(s1 >= s2) # 이렇게 계산하면 __ge__ 호출되고 x 인자값에 s2가 바로 넘어간다.
print(s1 <= s2) # 이렇게 계산하면 __le__ 호출되고 x 인자값에 s2가 바로 넘어간다.
Colored by Color Scripter

cs

위와같은 과정을 데이터 모델(data model)이라고 부르고

https://docs.python.org/3/reference/datamodel.html 공식 도큐먼트에서 확인가능하다.

우리를 위한 프로그래밍 : 파이썬 중급 를 기반으로 정리하였으며,

기본적인 내용보다는 실질적으로 Why? 라는 의문이 가질 법한 내용 위주로 정리하였습니다.

(class, instance, static) method_03

미카이 — Mon, 21 Mar 2022 14:48:03 +0900

이번시간에는 class, instance, static 메소드에 대해 알아보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

class Car(object): # 모든 클래스는 object를 상속받는다.
    """ # 파이써닉 규칙 (description)
    Car class
    Author: Mekai
    Data: 2021.03.21
    Description : Class, Static, Instance Method 
    """
    # 클래스 변수(모든 인스턴스가 공유)
    price_per_raise = 1.0
 
    def __init__(self, company, details):
        self._company = company
        self._details = details
        
    def __str__(self):
        return 'str : {} - {}'.format(self._company, self._details)
 
    def __repr__(self):
        return 'repr: {} - {}'.format(self._company, self._details)
 
    # Instance Method
    # self : 객체의 고유한 속성 값을 사용
    def detail_info(self): # self 매개변수로 받는것을 인스턴스 메소드(instance method)라고 한다
        print('Current ID : {}'.format(id(self)))
        print('Car Detail Info : {} {}'.format(self._company, self._details.get('price')))
    # Instance Method
    def get_price(self):
        return 'Before Car Price -> company : {}, price : {}'.format(self._company, self._details.get('price'))
    # Instance Method
    def get_price_culc(self):
        return 'After Car Price -> company : {}, price : {}'.format(self._company, self._details.get('price')* Car.price_per_raise)
 
 
    # class Method
    # instance method는 self를 인자값으로 받고, classmethod 는 cls는 인자로 받는다
    @classmethod # 명시적으로 쓰기 위해 데코레이터가 달려있다!
    def raise_price(cls, per): # cls는 객체 Car다.. 명시적으로 쓰는것!
        if per <= 1:
            print('Plaease Enter 1 or More')
            return
        else:
            cls.price_per_raise = per
            print('Succeed!')
 
    
    # static method는 아무것도 전달받지 않는다/ instance method는 self / classmethod는 cls 객체를
    # static method 없어도 cls로 다 할 수 있다는 의견들이 많다.. 인터넷 찾아보면 ~_~
    # 아무것도 받지 않기 때문에 유연하긴하다.. 공통적으로 만들때 쓰는것
    @staticmethod
    def is_bmw(inst): # bmw 차가 맞는지 판단하는..
        if inst._company =='Bmw':
            return 'OK! This car is {}'.format(inst._company)
        else:
            return 'Sorry. This car is not Bmw.'
    
 
 
car1 = Car('Ferrari', {'color': 'White', 'horsepower': 400, 'price': 8000})
car2 = Car('Bmw', {'color': 'Black', 'horsepower': 270, 'price': 5000})
Colored by Color Scripter

cs

자동차 2개 객체를 추가하여 위 클래스 기반으로 알아보도록 하자.

@classmethod

클래스 메소드는 cls를 인자값 받으며 명시적으로 쓰기 위해 @ (데코레이터)가 달려있다.

자기 자신을 의미하기 때문에 일반적으로 클래스 변수에 접근하기 위해 사용된다.

def detail_info(self):

인스턴스 메소드는 객체의 고유한 값을 가지고 self로 메소드를 만들고,

객체의 인스턴스 필드를 self를 통해 접근가능하다.

@staticmethod

스태틱 메소드는 아무것도 전달 받지 않기 때문에 유연하게 메소드를 만들 수 있고 공통적으로 무언가 만들때 자주 사용된다.

하지만 cls로 다 할 수 있다는 의견들이 많은데 인터넷 검색해보면 나온다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

# 전체정보 출력
car1.detail_info()
car2.detail_info()
 
# 가격정보 (직접 접근)
print(car1._details.get('price')) # 이렇게 접근할 수 있지만, 자기 인스턴스 변수에 직접 접근하는 방법은 좋지 않다. 막아놓는다.
print(car2._details['price']) # 이렇게 접근할 수 있지만, 자기 인스턴스 변수에 직접 접근하는 방법은 좋지 않다. 막아놓는다.
 
 
# 가격정보(인상 전->인스턴스 메소드 접근)
print(car1.get_price())
print(car2.get_price())
 
# 가격 인상
Car.price_per_raise = 1.4 # 사실 이렇게 직접 접근하는 방식은 좋지 않다.
# 가격정보(인상 후->인스턴스 메소드 접근)
print(car1.get_price_culc())
print(car2.get_price_culc())
 
 
# 가격 인상(클래스 메소드 사용)
Car.raise_price(1.6)
 
print(car1.get_price_culc())
print(car2.get_price_culc())
 
 
 
# Staticmethod
# 아래처럼 호출할 수 있지만 엄청나게 유연하다!
print(car1.is_bmw(car1))# 인스턴스로 호출
print(car2.is_bmw(car2))
# 이렇게 유연하게 호출도 가능.
print(Car.is_bmw(car1)) # 클래스로 호출
print(Car.is_bmw(car2))
Colored by Color Scripter

cs

간단정리하면 static method는 아무것도 전달받지 않고, instance method는 self, classmethod는 cls 객체를 전달 받는다.

우리를 위한 프로그래밍 : 파이썬 중급 를 기반으로 정리하였으며,

기본적인 내용보다는 실질적으로 Why? 라는 의문이 가질 법한 내용 위주로 정리하였습니다.

클래스 변수 & 인스턴스 변수([Class,Instance] variable)_02

미카이 — Mon, 21 Mar 2022 14:08:46 +0900

저번 포스팅에서 Why? 클래스를 사용할 지에 대한 이야기를 간략하게 해봤다.

이번에는 클래스 변수 및 인스턴스 변수가 어떻게 다른지에 대한 이야기를 해보겠다.

일반적으로 우리가 클래스를 만들게 된다면 object를 상속받게 되어있다.

class Car(object):

#to do..

하지만 object를 생략하고 만들어도 기본적으로 모든 클래스는 object를 상속받게 되어있다.

class Car():

# to do..

그럼 이제 자동차 클래스를 만들어보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

class Car(object): # 모든 클래스는 object를 상속받는다.
    """ 
    # 파이써닉 규칙 -> 클래스 내용을 적으세요
    Car class
    Author: Mekai
    Data: 2021.03.21
    """
 
    # 클래스 변수(모든 인스턴스가 공유)
    car_count = 0
 
    def __init__(self, company, details):
        self._company = company
        self._details = details
        self.car_count = 10
        Car.car_count += 1
 
    def __str__(self):
        return 'str : {} - {}'.format(self._company, self._details)
 
    def __repr__(self):
        return 'repr: {} - {}'.format(self._company, self._details)
 
    def detail_info(self):
        print('Current ID : {}'.format(id(self)))
        print('Car Detail Info : {} {}'.format(self._company, self._details.get('price')))
 
    def __del__(self):
        print('호출?')
        Car.car_count -= 1
 
car1 = Car('Ferrari', {'color': 'White', 'horsepower': 400, 'price': 8000})
car2 = Car('Bmw', {'color': 'Black', 'horsepower': 270, 'price': 5000})
car3 = Car('Audi', {'color': 'Silver', 'horsepower': 300, 'price': 6000})

cs

위와 같이 클래스를 만들고 3개의 객체(car1, car2, car3)를 만들어보자.

Car() 클래스를 보면 다음과 같은 의문이 들 수 있다.

- self 는 무엇을 의미하지 ?

- why 클래스 안에 변수에 self를 붙이는 변수가 있고 아닌 변수들이 있는데 무엇을 의미할까?

간략하게 self의 의미는 인스턴스(instance) 메소드라는 의미인데

car1 = Car('Ferrari', {'color': 'White', 'horsepower': 400, 'price': 8000})

이렇게 인스턴스를 만들고 할당되어있는 고유의 인스턴스 메소드라는 의미로 사용되며, 첫번째 매개변수로 넘어오는 것이 약속이다.

~~무슨말이냐 ?~~

1
2
3

print(id(car1))
print(id(car2))
print(id(car3))

cs

객체 할당 후 각 고유의 주소(id 메소드 활용)를 확인하면 각 각 다른 주소를 가지고 있는 것을 확인할 수 있다.

self는 각 고유의 값들을 가지고 있기에 인스턴스 고유값을 저장하기 위한 예약어이다(즉, 인스턴스 변수가 될 수 있다).

1
2
3
4
5
6
7
8
9
10

print(car1._company == car2._company) # False (값을 비교) -> 만약 둘 다 Bmw면 True다
print(car1 is car2) # False -> 아이디가 다르기때문 (인스턴스 자체 비교)
 
# dir & __dict__ 확인
print(dir(car1)) # 모든 클래스는 object를 상속받는데 object를 타고올라가면 메소드를 구성되어있는걸 모두 다 보여준다
print(dir(car2)) # 보면 _company, _details도 보여서 list 형태로 다 보여준다 
 
# 그래서 나는 부모꺼말고 내꺼만 보고싶어 내 namespace만 보고싶다
print(car1.__dict__)
print(car2.__dict__)
Colored by Color Scripter

cs

또한, 클래스 작성시

""" # 파이써닉 규칙

Car class

Author: Taehyung

Data: 2021.03.14

"""

위와 같이 클래스 설명을 써서 만들었는데 정보를 볼 수 있다.(docstring)

1

print(Car.__doc__) # 그 위에 클래스 작성에 달아놓은 """"""  작성 내용이 출력되고 아주 유용하게 사용된다.

cs

반면에 self가 붙어 있지 않다면 인스턴스가 아니라 클래스 변수가 된다.

예를들어 동일한 클래스(Car)로 인스턴스를 만들었다면 이 인스턴스끼리 클래스 변수는 모든 인스턴스가 공유가 된다.

Car.car_count += 1 를 넣어준다면 저 실행 값은 car_count가 3번 호출되었기에 값이 3이 된다.

1
2
3
4
5
6
7
8

# 공유 확인
print(Car.car_count)
print(car1.car_count)
print(car2.car_count)
print(car1.__dict__) # 클래스 내부에 정의된 인스턴스만 값만나온다
print(car2.__dict__) 
print(dir(car1)) # 모든 정의된 값이 나온다 -> 클래스 변수로 car_count 값이 나온다
# 약간 느낌이 .. 인스턴스 변수를 만들때 _ 를 붙이는 습관이.. 클래스 내부에서 _ 안붙이면 클래스 변수로 모두가 공유하는 

cs

1
2
3
4
5
6
7
8
9
10

# 접근
# 아래처럼 둘 다 접근이 가능하다..
print(car1.car_count) # 3
print(Car.car_count) # 3
 
 
del car2 # 소멸자 호출
# 삭제 확인
print(car1.car_count) # 2
print(Car.car_count)  # 2

cs

마지막으로 네임스페이스를 알아보자.

네임스페이스(namespace)란 프로그래밍 언어에서 특정한 객체(Object)를 이름(Name)에 따라 구분할 수 있는 의미를 가지고 있으며, 우리가 코딩하는 모든 파이썬은 객체로 구성되며 이들 각각은 특정 이름과 매핑 관계를 갖게 되는데 이를 네임스페이스라고 표현한다.

그래서 동일한 클래스로 객체를 만들었어도 다른 공간에 있는 변수가 될 수 있다.

인스턴스 네임스페이스에 없다면 상위에서 검색하는데

즉, 동일한 이름으로 변수 생성 가능 (인스턴스 검색 후 -> 상위(클래스 변수, 부모클래스 변수))

# 인스턴스 변수는 인스턴스 변수로, 클래스 변수는 캘래스 변수로 접근해야 한다.

1
2

print(car1.car_count) # 10
print(Car.car_count)  # 2

cs

아주 간략하게 정리하자면 self에 따라 인스턴스 변수가 될 수 있고, self가 없다면 클래스 변수가 될 수 있는데 클래스 변수는 상위 객체(object)에서 관리한다.

우리를 위한 프로그래밍 : 파이썬 중급 를 기반으로 정리하였으며,

기본적인 내용보다는 실질적으로 Why? 라는 의문이 가질 법한 내용 위주로 정리하였습니다.

클래스&메소드(class&method)_01

미카이 — Mon, 21 Mar 2022 13:11:16 +0900

초심자는 왜(Why) 클래스를 사용할까라는 의문이 들 수 있다. (물론 나도... 항상 초심)

예시를 보자.

만약 우리가 자동차 회사의 정보를 저장하는 업무가 주어졌다고 가정해보자.

필요한 내용은 자동차 (종류, 차량색상, 가격, 마력) 을 저장해야 된다고 가정하고,

일반적인 코딩은 다음과 같이 작성할 것이다.

파이썬 코드로 작성하면 다음과 같이 list, dict, str를 이용하여 코드를 만든다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

car_company_1 = 'Ferrari'
car_detail_1 = [
    {'color': 'White'},
    {'horsepower': 400},
    {'price: 8000'}
]
 
car_company_2 = 'Bmw'
car_detail_2 = [
    {'color': 'Black'},
    {'horsepower': 270},
    {'price': 5000}
]
 
car_company_3 = 'Audi'
car_detail_3 = [
    {'color': 'Silver'},
    {'horsepower': 300},
    {'price': 6000}
]

cs

하지만 위 처럼 코드를 작성하여 리스트 구조로 관리하게 되면,

지금은 3개의 종류만 저장하지만 수억개 이상이 된다면 관리가 불편하고 index로 접근 시 실수 가능성 및 삭제가 불편할 수 있다.

1
2
3
4
5

# 삭제 불편 및 관리 힘듦의 예시
del car_company_list[1] # 2번째 인덱스 삭제
del car_detail_list[1]
 
print(car_company_list)
print(car_detail_list)

cs

그렇다면 딕셔너리 구조로 만든다면 다음과 같이 코드를 작성할 수 있다.

1
2
3
4
5
6
7
8
9

car_dicts = [
    {'car_company': 'Ferrai', 'car_detail': {'color': 'White', 'horsepower': 400, 'price': 8000}},
    {'car_company': 'Bmw', 'car_detail': {'color': 'Black', 'horsepower': 270, 'price': 5000}},
    {'car_company': 'Audi', 'car_detail': {'color': 'Silver', 'horsepower': 300, 'price': 6000}}
]
print(car_dicts)
# 역시 지울땐, del 메소드를 이용해서 ..
del car_dicts[1]
print(car_dicts)
Colored by Color Scripter

cs

하지만 딕셔너리 구조도 마찬가지로, 위와같이 작성하게 된다면,

코드 반복 지속, 중첩(키) 문제, 키 조회 예외 처리 등등 다양한 문제가 발생할 수 있다.

이제 클래스 구조로 만들어보자

만들기 전 클래스 구조로 코드를 작성한다면

구조 설계 재사용성 증가, 코드 반복 최소화, 다양한 데코레이터를 이용한 메소드 활용에 이점이 있다.

(물론 잘 설계했을시....)

~~python class는 명사명으로 만드는 습관을 갖자.~~

1
2
3
4
5
6
7
8
9
10
11
12
13

class Car():
    def __init__(self, company, details):
        self._company = company
        self._details = details
 
    # 매직메소드 
    def __str__(self):
        return 'str : {} - {}'.format(self._company, self._details)
    
    # str메소드랑 비슷한데, 차이점은 쉽게말하면 representation인데
    # 비공식적인 사용자 입장에서 사용시에 str 메소드를 사용하고 / 객체 자료형 엄격한 타입에 따라 객체를 그대로 표시해줄때 repr 메소드를 사용한다
    def __repr__(self):
        return 'repr : {} - {}'.format(self._company, self._details)

cs

위와 같이 클래스를 만들게 된다면

우리는 필요할때마다 객체를 만들고 아래와 같이 사용할 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

car1 = Car('Ferrari', {'color': 'White', 'horsepower': 400, 'price': 8000})
car2 = Car('Bmw', {'color': 'Black', 'horsepower': 270, 'price': 5000})
car3 = Car('Audi', {'color': 'Silver', 'horsepower': 300, 'price': 6000})
print(car1) # str 메소드 구현시 자동 호출된다. / 기본적으로 str, repr 둘 다 구현되어 있을시 str이 호출된다.
print('__dict__',car1.__dict__) # dict로 접근하게되면 이 안에 속성(init의 attribute 값들을 볼 수 있다)
print(dir(car1)) # dir 메소드를 사용하면 객체안에 있는 모든 메타정보를 보여준다
 
# 리스트 선언
car_list = []
car_list.append(car1)
car_list.append(car2)
car_list.append(car3)
print(car_list) # list안에서 객체정보를 보여줄때는 str 메소드가 아니라 repr 메소드가 먼저 보여준다
 
for x in car_list:
    print(x) # 프린트문을 사용할때는 또, str이 출력되는 걸 볼 수 있다..? 
    print(repr(x)) # 명시적으로 보여줄 수 있기도 한다.
Colored by Color Scripter

cs

마지막으로 위와 객체 지향 프로그래밍 (OOP) 형식으로 작성하게되면 코드의 재사용, 코드 중복 방지, 유지보수, 대형프로젝트 시 협업할때 아주 유용하며,

클래스 중심 -> 데이터 중심 -> 객체로 관리 형식으로 데이터들을 관리 할 수 있다.

우리를 위한 프로그래밍 : 파이썬 중급 를 기반으로 정리하였으며,

기본적인 내용보다는 실질적으로 Why? 라는 의문이 가질 법한 내용 위주로 정리하였습니다.

RTX 3000 Series GPU Setting for window10

미카이 — Wed, 10 Feb 2021 12:31:16 +0900

최근 컴퓨터 조립으로 rtx 3000 series를 window 환경에서 setting을 하게되었다.

일단, pytorch 및 tensorflow gpu동작이 잘 되는것을 확인하였는데, 이 글을 통해 향 후 셋팅하면서 수고스러운일을 덜기 위해 작성한다.

GPU 는 RTX3090 기준으로 작성되었습니다.

1. Anaconda 설치

-> 최신 anaconda 대신 나는 이전 버전을 설치하였다

repo.anaconda.com/archive/ -> Anaconda3-2020.02-Windows-x86_64 검색해서 다운받을 수 있다.

2. CUDA 및 cudnn 설치

-> 이 부분이 gpu 사용을 위해 가장 중요한데,

2.1) CUDA ->CUDA Toolkit 11.1.1 -> 파일명(cuda_11.1.1_456.81_win10) -> install

2.2) CUDNN -> Download cuDNN v8.0.5 (November 9th, 2020), for CUDA 11.1 -> 파일명(cuda_11.1.1_456.81_win10cudnn-11.1-windows-x64-v8.0.5.39) -> 압축해제 -> CUDA경로(C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.1)로 들어가 덮어 씌우기를 한다.

덮어 씌울때 폴더는 (bin, include, lib, NVIDIA_SLA_cuDNN_Support.txt) 가 될것이다.

3. 가상환경 생성 및 tf, pytorch 설치 (tensorflow -> 2.4.0-rc0 / pytorch -> 1.7.1)

pytorch

-> conda create -n pytorch_test python=3.8

-> conda activate pytorch_test

-> conda install pytorch torchvision torchaudio cudatoolkit=11.0 -c pytorch

tensorflow

-> conda create -n tensorflow_test python=3.7

-> conda activate tensorflow_test

tensorflow whl 파일 다운2.4.0rc0-cp37 (링크)

-> pip install tensorflow-2.4.0rc0-cp37-cp37m-win_amd64.whl

-> pip install numpy==1.19.3

4. GPU test

pytorch

import torch

torch.cuda.is_available() # True

torch.cuda.get_device_name(0) # RTX 3090

torch.cuda.device_count() # 1

tensorflow

import tensorflow as tf

print(tf.__version__) # 2.4.0rc0

print(tf.test.is_gpu_available) # True

ps) 혹시나 'cudnn64_8.dll not found' 오류가 뜰 수 있다.

그럴땐 'C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.1\bin\bin' 경로에서 cudnn64_8.dll 파일을 복사후 상위 폴더에 붙어넣기 해주면 해결 할 수 있다.

-> 우분투에서는 설정하기 참 간편한데... 정신건강을 위해서는 우분투를 사용하는게 좋을 수 있을것같다. 여건만 된다면???

reference :

dailylime.kr/2020/11/tensorflow-on-rtx-3000-series/

github.com/tensorflow/tensorflow/issues/43193

dynamic programming

미카이 — Tue, 3 Nov 2020 11:08:59 +0900

다이나믹 프로그래밍
- 다이나믹 프로그래밍은 메모리를 적절히 사용하여 수행 시간 효율성을 비약적으로 향상시키는 방법입니다.
- 이미 계산된 결과(작은 문제)는 별도의 메모리 영역에 저장하여 다시 계산하지 않도록 합니다. (메모이제이션)
- 다이나믹 프로그래밍의 구현은 일반적으로 두 가지 방식(top-down, bottom-up)으로 구성됩니다.

또한, 다이나믹 프로그래밍은 동적 계획법이라고 부르며,
일반적인 프로그래밍 분야에서의 자료구조에서 동적 할당(Dynamic Allocation)은 '프로그램이 실행되는 도중에 실행에 필요한 메모리를 할당하는 기법'이라는 의미를 가지며 다이나믹 프로그래밍에 동적(Dynamic)은 별다른 의미 없이 사용된 단어라 헷갈리면 안된다.

다이나믹 프로그래밍은 문제가 다음의 조건을 만족할 때 사용할 수 있습니다.
1. 최적 부분 구조(Optimal Substructure)
  * 큰 문제를 작은 문제로 나눌 수 있으며 작은 문제의 답을 모아서 큰 문제를 해결할 수 있습니다.
2. 중복되는 부분 문제(Overlapping Subproblem)
  * 동일한 작은 문제를 반복적으로 해결해야 합니다.

대표적으로 피보나치 수열이 있다.
1,1,2,3,4,5,8,13,21,34,55,89 ...
점화식이란 인접한 항들 사이의 관계식을 의미한다.
피보나치 수열을 점화식으로 표현하는 다음과 같다.
a(n) = a(n-1) + a(n-2), a(1)=1, a(2)=1

def fibo(x):
    if x == 1 or x == 2:
        return 1
    else:
        return fibo(x-1) + fibo(x-2)
print(fibo(3))

위 처럼 단순 재귀 함수로 피보나치 수열을 해결하면 지수 시간 복잡도를 가지게 된다
ex) fibo(6) 를 호출하게 되면, f(2) 가 5번 호출된다. [중복되는 부분 문제]

중복 되는 함수 호출을 막기위해 메모이제이션(memoization)을 이용해서 해결 가능.
top-down 방식으로 / 한 번 계산한 결과를 메모리 공간에 메모하는 기법이고, 값을 기록해 놓는다는 점에서 캐싱(caching)이라고도 한다.

top-down VS bottom-up
탑다운(메모이제이션) 방식은 하향식이라고도 하며 바텀업 방식은 상향식이라고도 한다.
보통 전형적인 형태는 바텀업 방식이고, 결과 저장용 리스트는 DP 테이블이라고도 부른다.
엄밀히 말하면, 메모이제이션은 이전에 계산된 결과를 일시적으로 기록해 놓은 넓은 개념을 의미해 DP에만 국한된 개념은 아니다!

# 메모이제이션 방식(top-down)으로 피보나치 구현
# 아래 시간 복잡도는 O(N) 이다. 이유는 생각해보자.
d = [0] * 100 # 최대 100까지만 계산을 위해 리스트 초기화
def fibo(x):
    # print('f('+str(x)+')', end=' ')
    if x == 1 or x == 2: # 종료 조건
        return 1

    if d[x] != 0: # 이미 계산한 적 있으면 그대로 반환
        return d[x]

    d[x] = fibo(x-1) + fibo(x-2)
    return d[x]
print(fibo(99))

# bottom-up 방식으로 피보나치 구현
d = [0] * 100

d[1] = 1
d[2] = 1
n = 99

for i in range(3, n+1):
    d[i] = d[i-1] + d[i-2]
print(d[n])

다이나믹 프로그래밍(DP) VS  분할 정복(divide and conquer)
- 다이나믹 프로그래밍과 분할 정복은 모두 최적 부분 구조를 가질 때 사용할 수 있다
- dp와 분할 정복의 차이점은 부분 문제의 중복이라 dp 에선 각 부분 문제들이 서로 영향을 미치고 분할 정복에서는 동일한 부분 문제가 반복적으로 계산되지 않는다.

이게 생각보다 어려운데,
- DP 유형임을 파악하는게 중요한데, 가장 먼저 그리디, 완탐, 등의 아이디어로 문제를 해결할 수 있는지 검토하고 풀이 방법이 떠오르지 않는다면 다이나믹 프로그래밍을 고려
- 일단 재귀 함수로 비효율적인 완탐을 작성하고 작은 문제에서 구한 답이 큰 문제에서 그대로 사용될 수 있으면 코드를 개선하는 방법 사용
- 일반적인 코테 수준에서는 기본 유형의 DP 문제가 출제되서 쫄지 않아도 된다. 반복적인 연습을 통해서 이런유형을 익숙해질 수 있다

<문제> 개미전사
# 개미 전사는 부족한 식량을 충당하고자 메뚜기 마을의 식량창고를 몰래 공격하려고 한다. 메뚜기 마을에는 여러 개의 식량 창고가 있는데 식량창고는 일직선으로 이어져 있다.
# 각 식량창고에는 정해진 수의 식량을 저장하고 있으며 개미 전사는 식량창고를 선택적으로 약탈하여 식량을 빼앗을 예정입니다. 이때 메뚜기 정찰병들은 일직선상에 존재하는 식량창고 중에서 서로 인접한 식량창고가 공격받으면 바로 알아챌 수 있다.
# 따라서 개미 전사가 정찰병에게 들키지 않고 식량창고를 약탈하기 위해서는 최소한 한 칸 이상 떨어진 식량창고를 약탈해야 한다.
예)
창고(0)  창고(1)  창고(2)  창고(3)
  1          3         1          5
# 이때 개미 전사는 두 번째 식량창고와 네 번째 식량창고를 선택했을 때 최댓값인 8개의 식량을 빼앗을 수 있다.
# 개미 전사를 위해 식량창고 N개에 대한 정보가 주어졌을 때 얻을 수 있는 식량의 최댓값을 구하는 프로그램을 작성

# 입력 예시
# 첫째 줄에 식량창고의 개수 N이 주어집니다 (3 <= N <= 100)
# 둘째 줄에 공백을 기준으로 각 식량창고에 저장된 식량의 개수 K가 주어집니다 (0<=K<=1000)
4
1 3 1 5
출력
8

# 점화식
# ai=i번째 식량창고까지의 최적의 해 (얻을 수 있는 식량의 최댓값)
# ki=i번째 식량창고에 있는 식량의 양
# ai = max(ai-1, ai-2+ki)

n = int(input())
k = list(map(int, input().split(' ')))

# 앞서 계산된 결과를 저장하기 위한 dp 테이블 초기화
d_table = [0] * 100

d_table[0] = k[0]
d_table[1] = max(k[0], k[1])
for i in range(2, n):
    d_table[i] = max(d_table[i-1], d_table[i-2]+k[i])

print(d_table[n-1])

위 내용들은 이코테 youtube 및 책을 참고하였습니다

이코테 링크

책 링크

binary search

미카이 — Sun, 11 Oct 2020 17:19:54 +0900

이진탐색

순차 탐색(sequential search) : 리스트 안에 있는 특정한 데이터를 찾기 위해 앞에서부터 데이터를 하나씩 확인하는 방법
이진 탐색(binary search) : 정렬되어 있는 리스트에서 탐색 범위를 절반씩 좁혀가며 데이터를 탐색하는 방법
이진 탐색은 시작점, 끝점, 중간점이 존재

ex)
정렬되어 있는 리스트가 있다고 가정하고 4인 원소를 찾는 예시
[0, 2, 4, 6, 8, 12, 14, 16, 18] 시작점 0(index) 끝점 9 중간점 4 으로 설정하고, 중간점과 찾고자하는 원소값이 작다면 오른쪽 범위는 볼 필요가 없다.
[0, 2, 4, 6] 이렇게 탐색범위는 총 4개 줄어드는데, 시작점은 0 중간점은 1 끝점은 3이 된다. 이렇게 해도 원하는 4를 못찾았는데 이번에는 중간점에 있는 2보다 4가 더 작으므로 오른쪽만 본다
[4, 6] 시작점 0 끝점 1 중간점 0  -> 4를 찾았다.  총 3번의 step으로 원하는 값을 찾을 수 있다.

시간복잡도는 탐색 범위를 2로 나누는 것과 동일하므로 연산 횟수는 log2N에 비례하므로, O(logN)을 보장

# binary search with recursive
def binary_search_resursive(arr, target, start, end):
    if start > end:
        return None
    mid = (start+end) // 2

    # 찾은 경우 중간점 인덱스 반환
    if arr[mid] == target:
        return mid

    # 중간점의 값보다 찾고자 하는 값이 작은 경우 왼쪽 확인
    elif arr[mid] > target:
        return binary_search_resursive(arr, target, start, mid-1)

    # 중간점의 값보다 찾고자 하는 값이 큰 경우 오른쪽 확인
    else:
        return binary_search_resursive(arr, target, mid+1, end)

# binary search with for
def binary_search_for(arr, target, start, end):
    while start <= end:
        mid = (start + end) // 2

        # 찾은 경우 중간점 인덱스 반환
        if arr[mid] == target:
            return mid

        # 중간점 값보다 찾고자 하는 값이 작은 경우 왼쪽 확인
        elif arr[mid] > target:
            end = mid - 1

        # 중간점 값보다 찾고자 하는 값이 큰 경우 오른쪽 확인
        else:
            start = mid + 1

    return None # 못찾았다면 None 반환

# 원하는 원소 n 과 target list 가 몇개 인지 입력 받기
n, target = list(map(int, input().split()))

# 전체 원소 입력 받기
arr = list(map(int, input().split()))

result = binary_search_resursive(arr, target, 0, n-1)

"""
10 7
1 3 5 7 9 11 13 15 17 19
4
"""
if result == None:
    print('원소 없음')
else:
    print(result+1)

#  python binary search libary
from bisect import bisect_left, bisect_right

a = [1,2,4,4,8]
x = 4

print(bisect_left(a,x)) # 정렬된 순서를 유지하면서 배열 a에 x를 삽입할 가장 왼쪽 인덱스 반환 -> 2
print(bisect_right(a,x)) # 정렬된 순서를 유지하면서 배열 a에 x를 삽입할 가장 오른쪽 인덱스 반환 -> 4

# 특정 범위에 속하는 데이터 개수 구하기

# 값이 [left_value, right_value]인 데이터의 개수 반환하는 함수
def count_by_range(a, left_value, right_value):
    right_index = bisect_right(a, right_value)
    left_index = bisect_left(a, left_value)
    return right_index - left_index

a = [1, 2, 3, 3, 3, 3, 4, 4, 8, 9]

# 값이 4인 데이터 개수 출력
print(count_by_range(a, 4, 4)) # 2

# 값이 [-1, 3] 범위에 있는 데이터 개수 출력
print(count_by_range(a, -1, 3)) # 6

파라메트릭 서치(parametric search)
- 최적화 문제를 결정 문제(yes or no) 로 바꾸어 해결하는 기법
ex) 특정한 조건을 만족하는 가장 알맞은 값을 빠르게 찾는 최적화 문제
일반적으로 코딩 테스트에서는 이진 탐색을 이용하여 해결 가능

위 내용들은 이코테 youtube 및 책을 참고하였습니다

이코테 링크

책 링크

Sort Algorithm

미카이 — Sun, 11 Oct 2020 01:12:48 +0900

정렬 알고리즘

정렬(Sorting)이란 데이터를 특정한 기준에 따라 순서대로 나열하는 것을 말합니다.
일반적으로 문제 상황에 따라서 적절한 정렬 알고리즘이 공식처럼 사용된다.

아래 리스트를 어떻게 정렬할까 ?
[7, 5, 9, 0, 3, 1, 6, 2, 4, 8]

1. 선택 정렬(selection sort)
- 처리되지 않은 데이터 중 가장 작은 데이터를 선택해 맨 앞에 있는 데이터와 바꾸는 것을 반복

: [7, 5, 9, 0, 3, 1, 6, 2, 4, 8] 가장 작은 0을 선택해 7와 바꾼다.
: [0, 5, 9, 7, 3, 1, 6, 2, 4, 8] 다음 작은 1를 선택해 5와 바꾼다.
: [0, 1, 9, 7, 3, 5, 6, 2, 4, 8] 다음 작은 2을 선택해 9와 바꾼다.
: [0, 1, 2, 7, 3, 5, 6, 9, 4, 8] 위 작업을 계속 반복한다.
: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 마지막 경우에는 처리하지 않아도 된다.
탐색할때마다 범위가 줄어드는데 매번 작은 값을 찾기위해 탐색 범위만큼 확인해서 찾아야되기 때문에
매번 선형탐색을 수행하는 것과 동일
N + (N-1) + (N-2) + ... + 2 이므로 (N^2+N-2)/2 로 표현 가능하지만 빅오 표기법으로 O(N^2) 의 시간 복잡도를 가진다.

# 선택 정렬
arr = [7, 5, 9, 0, 3, 1, 6, 2, 4, 8]

for i in range(len(arr)):
    min_index = i # 가장 작은 원소 인덱스
    for j in range(i+1, len(arr)): # 탐색해야 할 인덱스
        if arr[min_index] > arr[j]:
            min_index = j
    arr[i], arr[min_index] = arr[min_index], arr[i] # 작은 인덱스와 바꾼다

print(arr)

2. 삽입 정렬(insertion sort)
- 처리되지 않은 데이터를 하나씩 골라 적절한 위치에 삽입
- 선택 정렬에 비해 구현 난이도가 높지만, 일반적으로 더 효율적으로 동작

: [7, 5, 9, 0, 3, 1, 6, 2, 4, 8] 맨 앞 7은 정렬되어 있다고 가정하고 그 다음 원소인 5가 어떤 위치로 들어갈지 판단하여 7이랑 비교해서 앞으로 갈지 뒤로 갈지 판단
: [5, 7, 9, 0, 3, 1, 6, 2, 4, 8] 그 다음 앞 두개는 정렬되어 있다고 가정하고 그다음 원소인 9가 어떤 위치로 들어갈지 판단해 정렬
: [5, 7, 9, 0, 3, 1, 6, 2, 4, 8] 그 다음 앞 세개는 정렬되어 있다고 가정하고 그다음 원소인 0가 어떤 위치로 들어갈지 판단해 정렬(정렬된 원소랑만 비교하므로 가장 앞으로 간다)
: [0, 5, 7, 9, 3, 1, 6, 2, 4, 8] 그 다음 앞 네개는 정렬되어 있다고 가정하고 그다음 원소인 3가 어떤 위치로 들어갈지 판단해 정렬
: [0, 3, 5, 7, 9, 1, 6, 2, 4, 8] 그 다음 앞 네개는 정렬되어 있다고 가정하고 그다음 원소인 3가 어떤 위치로 들어갈지 판단해 정렬
: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 위 작업을 계속 반복해 모든 원소가 정렬될때까지 반복

삽입 정렬의 시간 복잡도는 O(N^2)이며, 현재 리스트의 데이터가 거의 정렬되어 있는 상태라면 매우 빠르게 동작하는 장점이 있다. 최선의 경우는 O(N)

# 삽입 정렬
arr = [7, 5, 9, 0, 3, 1, 6, 2, 4, 8]

for i in range(1, len(arr)):
    for j in range(i, 0, -1): # 인덱스 i부터 1까지 1씩 감소하며 반복하는 문법
        if arr[j] < arr[j-1]: # 한 칸씩 왼쪽으로 이동
            arr[j], arr[j-1] = arr[j-1], arr[j]
        else: # 자기보다 작은 데이터 만나면 그 위치에서 멈춤
            break

print(arr)

3. 퀵 정렬(quick sort)
- 기준 데이터를 설정하고 그 기준보다 큰 데이터와 작은 데이터의 위치를 바꾸는 방법
- 병합 정렬과 더불어 대부분의 프로그래밍 언어의 정렬 라이브러리의 근간이 되는 알고리즘
- 가장 기본적인 퀵 정렬은 첫 번째 데이터를 기준 데이터(pivot)로 설정

: [5, 7, 9, 0, 3, 1, 6, 2, 4, 8] 현재 pivot 값은 5이라고 가정하고, 왼쪽부터 5보다 큰 데이터를 선택하므로 7이 선택되고 오른쪽부터 5보다 작은 데이터를 선택하므로 4가 선택되고 위치를 바꿈
: [5, 4, 9, 0, 3, 1, 6, 2, 7, 8] 마찬가지로 pivot이 5이므로 왼쪽에서 부터 검색하고해서 큰값을 검색하고 오른쪽에서 부터 큰 값을 찾아 위치를 바꾼다.
: [5, 4, 2, 0, 3, 1, 6, 9, 7, 8] 현재 pivot 값이 5이므로 왼쪽부터 큰 값인 6이 선택되고 오른쪽에서는 작은값이 1이 선택되는데, 이처럼 위치가 엇갈리는 경우 pivot과 작은 데이터의 위치를 서로 변경
: [1, 4, 2, 0, 3, 5, 6, 9, 7, 8] 이제 5의 왼쪽에 있는 데이터는 모두 5보다 작고, 왼쪽에 있는 데이터는 5보다 크다는 특징이 생기는데, 데이터 묶음을 나누는 작업을 분할(divide)라고 한다.
: [1, 4, 2, 0, 3, 5, 6, 9, 7, 8] 5를 기준으로 나눠진 부분을 정렬을 마찬가지로 계속 수행해준다.
: [1, 0, 2, 4, 3, 5, 6, 9, 7, 8] 계속 재귀적으로 정렬해주면 정렬이 완료 될것이다.

이상적인 경우 분할이 절반씩 일어난다면 전체연산 횟수로 O(NlogN)을 기대 할 수 있다. 최악은 O(N^2)
너비 x 높이 = N * logN = NlogN

삽입 정렬의 시간 복잡도는 O(N^2)이며, 현재 리스트의 데이터가 거의 정렬되어 있는 상태라면 매우 빠르게 동작하는 장점이 있다. 최선의 경우는 O(N)

arr = [5, 7, 9, 0, 3, 1, 6, 2, 4, 8]

def quick_sort(arr, start, end):
    if start >= end: # 원소가 1개인 경우 종료
        return
    pivot = start # pivot은 첫 번재 원소
    left = start + 1
    right = end
    while(left <= right):
        # pivot보다 큰 데이터를 찾을 때까지 반복
        while(left <= end and arr[left] <= arr[pivot]):
            left += 1
        # pivot보다 작은 데이터를 찾을 때까지 반복
        while(right > start and arr[right] >= arr[pivot]):
            right -= 1
        if (left > right): # 왼쪽에서 작은 데이터랑 오른쪽에서 큰 데이터가 엇갈렸다면 pivot 교체
            arr[right], arr[pivot] = arr[pivot], arr[right]
        else: # 엇갈리지 않았다면 작은 데이터와 큰 데이터 교체
            arr[left], arr[right] = arr[right], arr[left]

    # 분할 이후 왼쪽 부분과 오른쪽 부분에서 각각 정렬 수행
    quick_sort(arr, start, right-1)
    quick_sort(arr, right + 1, end)
quick_sort(arr, 0, len(arr)-1)
print(arr)


# 파이썬 장점 살린 버전
arr = [5, 7, 9, 0, 3, 1, 6, 2, 4, 8]

def quick_sort_1(arr):
    # list 하나 이하의 원소만을 담고 있다면 종료
    if len(arr) <= 1:
        return arr
    pivot = arr[0] # pivot은 첫 번재 원소
    tail = arr[1:] # 피벗을 제외한 리스트

    left_side = [x for x in tail if x <= pivot] # 분할된 왼쪽 부분
    right_side = [x for x in tail if x > pivot] # 분할된 오른쪽 부분

    # 분할 이후 왼쪽 부분과 오른쪽 부분에서 각각 정렬 수행 후 전체 리스트 반환
    return quick_sort_1(left_side) + [pivot] + quick_sort_1(right_side)
print(quick_sort_1(arr))

4.  계수 정렬(counting sort)
- 특정한 조건이 부합할 때만 사용할 수 있지만 매우 빠르게 동작하는 정렬 알고리즘
- 계수 정렬은 데이터의 크기 범위가 제한되어 정수 형태로 표현할 수 있을 때 사용 가능
- 데이터의 개수가 N, 데이터(양수) 중 최대값이 K 일 때 최악의 경우에도 수행 시간 O(N+K)를 보장

: [7, 5, 9, 0, 3, 1, 6, 2, 9, 1, 4, 8, 5, 2] 0 ~ 9 까지 테이블 표로 만들어놓고 각각 count table를 계산한다
: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] [2, 2, 2, 1, 1 ,2, 1, 1, 1, 2]   인덱스/ 개수  이렇게 만들 수 있다. index 접근하는건 O(N) 이라고 가정할때
: [0, 0, 1, 1, 2, 2, 3, 4, 5, 5, 6, 7, 8, 9, 9] # 결과를 확인할 때는 리스트의 첫 번재 데이터부터 하나씩 그 값을 반복하여 인덱스 출력

계수 정렬의 시간 복잡도와 공간 복잡도는 모두 O(N+K)이다
때에 따라서 비효율성을 초래할 수 있다. ex) 0, 999999  2개만 존재하는 경우 데이터 범위가 너무 크다..
동일한 값을 가지는 데이터가 여러 개 등장할 때 효율적으로 사용

# 모든 원소의 값이 0보다 크거나 같다고 가정
arr = [7, 5, 9, 0, 3, 1, 6, 2, 9, 1, 4, 8, 5, 2]
# 모든 범위를 포함하는 리스트 선언
count = [0] * (max(arr) + 1)

for i in range(len(arr)):
    count[arr[i]] += 1 # 각 데이터에 해당하는 인덱스의 값 증가

for i in range(len(count)): # 리스트에 기록된 정렬 정보 확인
    for j in range(count[i]):
        print(i, end = '')

위 내용들은 이코테 youtube 및 책을 참고하였습니다

이코테 링크

책 링크

DFS / BFS

미카이 — Fri, 9 Oct 2020 16:37:23 +0900

그래프 탐색 알고리즘 : DFS / BFS

탐색(search)이란 많은 양의 데이터 중에서 원하는 데이터를 찾는 과정을 말합니다.

대표적인 그래프 탐색 알고리즘으로는 DFS와 BFS가 있습니다.

DFS / BFS는 코딩 테스트에서 매우 자주 등장하는 유형이므로 반드시 숙지해야 합니다.

DFS 와 BFS 알고리즘을 알아보기 전에 반드시 숙지해야할 두가지 자료구조와 재귀 함수가 있다.

1. 스택(stack) 자료구조

- 먼저 들어온 데이터가 나중에 나가는 형식(선입후출)의 자료구조입니다.

- 간단하게 삽입(insert), 삭제(delete) 연산이 있는데 삽입하면 제일 끝에 쌓이고, 삭제하면 제일 뒤에 있는 데이터부터 삭제된다.

python으로는 간단하게 리스트를 이용하면 된다.

stack = []

stack.append(5) # 삽입 5 -> [5]

stack.append(3) # 삽입 3 -> [5,3]

stack.pop() # 삭제 -> [5]

2. 큐(queue) 자료구조

- 먼저 들어 온 데이터가 먼저 나가는 형식(선입선출)의 자료구조입니다.

- 큐도 마찬가지로 삽입(insert), 삭제(delete) 연산이 있는데 삽입하면 제일 끝에 쌓이고, 삭제하면 제일 앞에 있는 데이터부터 삭제된다.

python으로 간단하게 리스트를 이용해도 되고, deque를 이용해도 된다.

하지만 비용적으로 deque를 이용하는게 시간복잡도적으로 빠르기 때문에, deque를 이용

q = []

q.append(5) # 삽입 5 -> [5]

q.append(3) # 삽입 3 -> [5,3]

q.pop(1) # 삭제 -> [3]

from collections import deque

queue = deque()

queue.append(5) # 삽입 5 -> [5]

queue.append(3) # 삽입 3 -> [5,3]

queue.append(8) # 삽입 8 -> [5,3,8]

queue.popleft() # 삭제 -> [3,8]

3. 재귀 함수(recursive function)란 자기 자신을 다시 호출하는 함수를 의미

- 재귀 함수는 우리가 실질적으로 bfs dfs를 구현하고자 할때 자주 사용되는 방법중 하나이므로 꼭 이해해야 한다.

- 재귀 함수를 문제 풀이에서 사용할 때는 재귀 함수의 종료 조건을 반드시 명시해야 한다.

- 단, 오히려 다른 사람이 이해하기 어려운 형태의 코드가 될 수도 있으므로 신중하게 사용해야 한다.

ex)

def recursive_function(i):

if i == 100:

return

print(i, '번째 재귀 함수에서', i+1, '번째 재귀 함수를 호출')

recursive_function(i+1)

print(i,'번째 재귀 함수를 종료합니다.')

recursive_function(1)

이제 본론으로 들어가 DFS(depth-first search)를 알아보자

- DFS는 깊이 우선 탐색이라고도 부르며 그래프에서 깊은 부분을 우선적으로 탐색하는 알고리즘이다

- DFS는 스택 자료구조(혹은 재귀 함수)를 이용하며, 구체적인 동작 과정은 다음과 같다.

1. 탐색 시작 노드를 스택에 삽입하고 방문 처리를 한다.

2. 스택의 최상단 노드에 방문하지 않은 인접한 노드가 하나라도 있으면 그 노드를 스택에 넣고 방문 처리하고 방문하지 않은 인접 노드가 없으면 스택에서 최상단 노드를 꺼낸다.

3. 더 이상 2번의 과정을 수행할 수 없을 때까지 반복

* 만약 그래프 구조를 어떻게 만들고 싶은지 알고 싶다면 참고 (https://boysboy3.tistory.com/139?category=859376)

* 어떻게 동작하고 간단한 코드를 어떻게 작성하는지 알고싶다면 참고 (https://blog.naver.com/wpghks7/221598474816) - 잘 나와있다..

# simple dfs

def dfs(graph, v, visited):

# 현재 노드를 방문 처리

visited[v] = True

print(v, end=' ')

# 현재 노드와 연결된 다른 노드를 재귀적으로 방문

for i in graph[v]:

if not visited[i]:

dfs(graph, i, visited)

# 그래프가 어떻게 표현되어 있는지 구조화 되어있다. 인접 리스트(adjacency list)라고 한다.

# 예를들면 0번 노드에는 암것도 연결된 노드가 없으니 1번 노드에는 2번,3,8 번 노드가 ... 이런식으로 되어 있는 리스트이다.

graph = [

[],

[2, 3, 8],

[1, 7],

[1, 4, 5],

[3, 5],

[3, 4],

[7],

[2, 6, 8],

[1, 7]

]

# 각 노드가 방문된 정보를 표현 (1차원 리스트) 8번까지 있지만 0노드는 사용 안하므로 9개의 list로 만든다.

visited = [False] * 9

# DFS 함수 호출 (시작 노드는 1번)

dfs(graph, 1, visited) # 1,2,7,6,8,3,4,5

다음으로 BFS(breadth-first search)를 알아보자

- BFS는 너비 우선 탐색이라고 부르며, 그래프에서 가까운 노드부터 우선적으로 탐색하는 알고리즘이다.

- BFS는 큐 자료구조를 이용하며, 다음과 같이 동작한다

1. 탐색 시작 노드를 큐에 삽입하고 방문 처리를 한다.

2. 큐에서 노드를 꺼낸 뒤에 해당 노드의 인접 노드 중에서 방문하지 않은 노드를 모두 큐에 삽입 후 방문 처리

3. 더 이상 2번의 과정을 수행할 수 없을 때까지 반복

BFS는 간선의 cost가 동일하다는(1) 가정하에 최단거리 문제를 해결할 수 있다는 점을 기억해야 한다.

# simple bfs

from collections import deque

# BFS method 정의

def bfs(graph, start, visited):

# 큐(queue)를 구현하기 위해 deque 라이브러리 사용

queue = deque([start])

# 현재 노드 방문 처리

visited[start] = True

# queue가 빌 때까지 반복

while queue:

# 큐에서 하나의 원소 봅아 출력

v = queue.popleft()

print(v, end=' ')

# 아직 방문하지 않은 인접한 요소들을 큐에 삽입

for i in graph[v]:

if not visited[i]:

queue.append(i)

visited[i] = True

graph = [

[],

[2, 3, 8],

[1, 7],

[1, 4, 5],

[3, 5],

[3, 4],

[7],

[2, 6, 8],

[1, 7]

]

# 방문된 정보 표

visited = [False] * 9

# BFS 함수 호출 (시작 노드는 1번)

bfs(graph, 1, visited) # 1,2,7,6,8,3,4,5

그 외 문제를 더 풀어보고 싶다면

얼음 얼려 먹기

미로 탈출

위 내용들은 이코테 youtube 및 책을 참고하였습니다

이코테 링크

책 링크

Greedy Algorithm & Implementation

미카이 — Wed, 7 Oct 2020 00:18:55 +0900

그리디 알고리즘 (Greedy Algorithm)

- 그리디 알고리즘(탐욕법)은 현재 상황에서 지금 당장 좋은 것만 고르는 방법을 의미
- 일반적인 그리디 알고리즘은 문제를 풀기 위한 최소한의 아이디얼르 떠올릴 수 있는 능력을 요구
- 단순히 가장 좋아 보이는 것을 반복적으로 선택해도 최적의 해를 구할 수 있는 검토하여 문제를 풀어야 한다 (모든 경우 지금 당장 좋은 것만 고르는 방법이 최고의 방법이 아니므로)

대표적으로 동전 거스름돈 문제가 있다.
500원 / 100원 / 50원 / 10원 짜리 동전이 무한히 존재하는데 손님에게 거슬러 줘야 할 돈이 N원일 때 거슬러줘야 할 동전의 최소 개수를 구하라. 단, 돈 N은 항상 10의 배수이다.

N이 1,280원이라면?

500 - 2
100 - 2
50 - 1
10 - 3
이렇게 해서 최소 동전 개수는 8개가 될 것이다.

이 문제에서 왜 가장 큰 화폐 단위부터 돈을 거슬러 주는게 최적의 해를 보장하는 이유가 무엇일까?
- 가지고 있는 동전 중 큰 단위가 항상 작은 단위의 배수이므로 작은 단위의 동전들을 종합해 다른 해가 나올 수 없기 때문

이걸 코드로 옮기면 다음과 같다.
간단한 문제이므로 해설은 하지 않겠다.

money = [500, 100, 50, 10]
money_count = 0

N = int(input())

for i in money:
    share = N // i  # 몫 ->> 해당 화폐로 거슬러 줄 수 있는 동전 개수 세기
    remainder = N % i # 나머지 ->> 동전 개수 나머지 금액

    money_count += share
    N = remainder

print(money_count)


구현(Implementation)

- 구현이란, 머릿속에 있는 알고리즘을 소스코드로 바꾸는 과정
- 모든 문제가 구현이라고 생각할 수 있지만 일반적으로 풀이를 떠올리는 것은 쉽지만 소스코드로 옮기기 어려운 문제를 지칭
- 알고리즘은 간단한데 코드가 길어지는 문제 등등
- 개인적으로 삼성 코테나 다양한 구현문제는 BFS, DFS 등 을 섞어서 복잡하게 내는 '빡구현'이라고 표현하는 문제들이 자주 출제된다.

그 중 구현 중 대표적인 문제 유형으로 시뮬레이션이나 완전 탐색 문제에서는 2차원 공간에서의 방향 벡터가 자주 활용되는데, 다음 코드가 자주 활용될 것이다.
* 시뮬레이션: 문제에서 제시한 알고리즘을 한 단계씩 차례대로 직접 수행해야 하는 문제 유형
* 완전 탐색 : 모든 경우의 수를 주저 없이 다 계산하는 해결 하는 문제 유형

# 동 서 남 북
dx = [0, 0, 1, -1]
dy = [1, -1, 0, 0]

# init position
x, y = 2, 2

for i in range(4):
    # 다음 위치
    nx = x + dx[i]
    ny = y + dy[i]
    print(nx, ny) # 동 서 남 북 순서로 탐색하게 된다.

# result
# 2 3
# 2 1
# 3 2
# 1 2

# 또한, 파이썬으로 구현하다보면 리스트가 1000만 이상인 경우 메모리 용량 제한으로 못 풀 경우가 있을 수 있을거고 수행시간이 1초라는 시간을 뒀을때 약 2000만 번의 연산을 수행한다고 가정하고 문제를 풀면 실행 시간 제한에 안정적일 것이다.
-> 시간 제한이 1초이고, 데이터의 개수가 100만 개라면 시간 복잡도 O(NlogN) 이내의 알고리즘을 이용해서 풀어야한다.

대표적인 시뮬레이션 문제를 살펴보자

상하좌우 문제
ex)여행가 A는 N x N 크기의 정사각형 공간 위에 서 있다. 이 공간은 1 x 1 크기의 정사각형으로 나누어져 있다. 가장 왼쪽 위 좌표는 (1,1)이며, 가장 오른쪽 아래 아래 좌표는 (N,N)에 대항한다. 여행가 A는 상, 하, 좌, 우 방향으로 이동할 수 있으며, 시작 좌표는 항상 (1,1) 이다.
우리 앞에는 여행가 A가 이동할 계획이 적힌 계획서가 놓여 있다.
L,R,U,D (왼쪽, 오른쪽, 위쪽, 아래쪽) 한칸씩 이동하라는 명령이고, 정사각형 공간을 벗어나는 움직임은 무시된다. 이때, 여행가 A 가 최종적으로 도착할 지점의 좌표 (X,Y)를 구해라
5 (공간의 크기 N)
R R R U D D (계획서 A)
정답 : 3 4

N = int(input())
A = list(input().split(' '))
pos = [1,1]

move_x = [0,0,1,-1]
move_y = [1,-1,0,0]
move_types = ['R', 'L', 'D', 'U']
for move in A: # 이동 계획 하나 씩 확인
    for i in range(4):

        if move == move_types[i]:
            nx = pos[0] + move_x[i]
            ny = pos[1] + move_y[i]

    # 공간을 벗어나는 경우 그 해당 계획은 무시한다
    if nx < 1 or ny < 1 or nx > N or ny > N:
        continue

    # 이동 수행
    pos[0] = nx
    pos[1] = ny

print(pos[0], pos[1])

위 내용들은 이코테 youtube 및 책을 참고하였습니다

이코테 링크

책 링크

Tensorflow & Keras 버전확인

미카이 — Thu, 2 Apr 2020 23:40:21 +0900

https://docs.floydhub.com/guides/environments/

List of Available Environments - FloydHub Documentation

edit Environments Below is the list of Deep Learning environments supported by FloydHub. Any of these can be specified in the floyd run command using the --env option. If no --env is provided, it uses the tensorflow-1.9 image by default, which comes with P

docs.floydhub.com

위 주소로 들어가면 확인할 수 있고, Docker Image 까지 다운로드 가능하다... 참좋다.

자주쓰는버전을 살펴보면

TensorFlow 2.0.0 + Keras 2.3.1 on Python 3.6.

TensorFlow 1.14.0 + Keras 2.2.5 on Python 3.6.

TensorFlow 1.11.0 + Keras 2.2.4 on Python 3.6.

2. Pytorch - Autograd

미카이 — Mon, 24 Feb 2020 00:29:12 +0900

저번시간에는 Tensor에 대해 알아봤다 궁금하다면? 클릭

이번시간에는 딥러닝 라이브러리를 사용하는 이유이자, 딥러닝의 꽃? 이라고 불릴 수 있는(backpropagation?)을 자동으로 해주는 autograd에 대해 알아보자.

Autograd ?

- Tensor의 모든 연산에 대해 자동 미분을 제공하는 패키지이다.

- 실행-기반-정의 (define-by-run) 프레임워크로, 코드를 어떻게 작성하여 실행하느냐에 따라 역전파(backpropagation)가 정의된다는 것. 만약 backpropagation을 알고싶다면 클릭

- 자동 미분 계산을 위해서 torch.autograd 패키지 안에 있는 Variable을 이용해야 동작이 가능해진다.

Variable ?

- autograd.Variable 클래스가 있는데, 이는 Tensor를 wrap 있으며 ,Tensor 기반으로 정의된 거의 대부분의 연산을 지원

- 계산이 완료된 후, .backward() 함수를 호출하여 gradient를 자동으로 계산할 수 있다.

- autograd.Variable이 넓은 범위로 안에 data, grad, grad_fun로 Variable이 구성되어있는데,

data 는 Tensor형태의 데이터가 담기고, grad는 data가 거쳐온 layer에 대한 미분값이 축적되며, grad_fn는 미분 값을 계산한 함수에 대한 정보를 담고있다.

ex)

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

import torch

from torch.autograd import Variable

a = torch.ones(2,2)

a = Variable(a, requires_grad=True) # a에 gradient값이 필요하다라는 의미

print(a) # torch.FloatTensor of size 2x2

b = a + 2

c = b**2

out = c.sum()

out.backward() # ∂out/∂a이다. 즉,out을 a로 미분해라 라는 의미.

print(a.data) # 1 1

# 1 1

print(a.grad) # 6 6

# 6 6

print(a.grad_fn) # None a가 직접적으로 수행한 연산은 없기에..

print(c.grad_fn) # pow backward object

print(out.grad_fn) # sum backward object

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

ex2)

import torch

from torch.autograd import Variable

x = torch.ones(3)

x = Variable(x, requires_grad=True)

y=x**2

z=y+3

grad=torch.Tensor([0.1, 1, 10])

z.backward(grad) # backward안에 값을 넣게되면 크기를 맞춰준다

print(x.grad) # 그래서 0.600, 6.000, 60.000 이 나오게 된다.

reference

https://evan-moon.github.io/2018/07/19/deep-learning-backpropagation/

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

https://9bow.github.io/PyTorch-tutorials-kr-0.3.1/beginner/blitz/autograd_tutorial.html#sphx-glr-beginner-blitz-autograd-tutorial-py

1. Pytorch - Tensor

미카이 — Mon, 24 Feb 2020 00:24:57 +0900

다양한 딥러닝 패키지 중, Pytorch를 빠르게 익히고자 정리를 합니다.

내용은 Pytorch tutorial, youtube를 기반으로 정리하였습니다.

Pytorch ?

- torch(lua)에서 pytorch(python)로 넘어오게 되었으며, python 기반의 과학 컴퓨팅 패키징이다.

- Numpy를 GPU를 통해 가속화해서 빠른 연산이 가능하다.

- 개인적으로, tf에 비해 코드가 좀 더 직관적인 면이 있다. ~~약간 class로 다 만들어서 그런가..?~~

Tensor ?

- Tensor는 pytorch의 자료 형

- 단일 데이터 타입으로 된 다차원 행렬이다. (일반적으로 ? 0d scalar, 1d vector, 2d matrix, 3d~nd tensor)

- Tensor는 간단한 명령어 [.cuda()] 를 추가하면 gpu로 연산이 가능

- 더 많은 pytorch의 tensor종류는 클릭

Tensor Use

만약 pytorch가 설치가 안되어 있다면 클릭

import torch

x = torch.Tensor(3)

print(x) # 초기화 되지 않은 tensor 생성 [torch.FloatTensor of size 3]

x2 = torch.Tensor(3,3)

print(x2) # [torch.FloatTensor of size 3x3]

x3 = torch.rand(3,3)

print(x3) # rand는 0~1 사이의 uniform distribution random 값으로 선언

x4 = torch.randn(3,3)

print(x4) # randn는 평균이 0, 분산이 1인 normal distribution random 값으로 선언

Numpy -> Tensor 변환 및 Tensor -> Numpy 변환

# .Tensor() / .numpy()

import torch

import numpy as np

a = np.array([1,2,3,4])

b = torch.Tensor(a) # numpy array -> tensor convert

a1 = torch.Tensor(3)

b1 = a1.numpy() # tensor -> numpy array convert

Tensor 형태 변환

# .view()

import torch

a = torch.rand(3,3) # (3x3 크기의 2차원 tensor생성)

a = a.view(1,1,3,3)

print(a) # (1x1x3x3) 형태의 4차원 tensor 생성

Tensor 이어 붙이기

# .cat()

import torch

a = torch.rand(1,1,3,3)

b = torch.randn(1,1,3,3)

c = torch.cat((a,b),0) # tensor, axis

GPU 계산 (cpu버전말고, gpu버전 깐 사람만 해당)

# .cuda()

import torch

x = torch.rand(3,3)

y = torch.rand(3,3)

# torch.cuda.get_device_name(0) # 자신의 그래픽카드가 나온다.

# print(torch.__version__) # torch 버전확인

if torch.cuda.is_available():

x = x.cuda()

y = y.cuda()

sum = x + y

그 외에 다양한 함수는 https://pytorch.org/docs/stable/torch.html

plt.imshow & cv2.imshow

미카이 — Sat, 22 Feb 2020 01:46:39 +0900

Python을 이용하여 이미지를 보여주거나 확인할때 가장 많이 사용하는 cv2.imshow와 plt.imshow 함수의 간단한 차이점을 살펴보겠다.

사용할 이미지로는 구글 로고를 이용하겠다.

구글 로고 이미지

필요 라이브러리 import

import cv2

import matplotlib.pyplot as plt

from matplotlib.image import imread

# image load

mat_img = image.imread('90.png') # (230, 579, 4)

cv_img = cv2.imread('90.png' ,0) # (230, 579)

.png 파일로 저장되어 있기때문에, matplot 에 imread로 읽을시 원본 그대로 읽는것 같다. 그래서 4채널로 들어오게 되는데 만약 cv 함수로 원본 그대로 읽고 싶다면, cv2.imread('90.png', -1) 인자값을 주면 alpha 값까지 읽을것이다. (0:gray, 1: rgb, -1: origin)

# image show

plt.imshow(cv_img)

cv2.imshow('gray image', cv_img)

cv2.waitKey(0)

cv2.destroyAllWindows()

(plt.imshow / cv2.imshow) [result]

gray로 읽었는데 출력을 해보면, cv2.imshow와 plt.imshow 함수 결과가 다를 수 있는데, plt.imshow 함수는 default 값이 color로 출력하게 되어있어서 내부적으로 변환이 이뤄지는것 같은데, cmap(color map)형식 인자값을 다양하게 변경가능하며, plt.imshow(cv_img, cmap='gray') 으로 변경하면 gray형식으로 출력되는것을 확인할 수 있다. 하지만 내부적으로 color를 조절해서 조금은 다른 결과가 나올 수 있다.

plt.imshow(cv_img, cmap='gray')

tip.. 출력은 plt.imshow로 여러장을 한번에 출력하는게 편해서 좋지만, 원본 타입을 보고싶다면 cv2.imshow 함수를 이용하고 read는 cv2로 읽는게 훨씬 빠르다 애용하자 ~_~

전체코드는 아래와 같습니다.

import cv2

import matplotlib.pyplot as plt

import matplotlib.image as image

# image load

mat_img = image.imread('90.png') # (230, 579, 4)

cv_img = cv2.imread('90.png', 0) # (230,579, 4)

# image show

plt.imshow(cv_img, cmap='gray')

cv2.imshow('gray image', cv_img)

cv2.waitKey(0)

cv2.destroyAllWindows()

ref : https://matplotlib.org/3.1.1/contents.html

Custom Dataset으로 Retinanet 학습하기

미카이 — Wed, 12 Feb 2020 00:08:05 +0900

https://github.com/fizyr/keras-retinanet

fizyr/keras-retinanet

Keras implementation of RetinaNet object detection. - fizyr/keras-retinanet

github.com

위 깃허브를 참고하였으며, Window10 / Anaconda 환경을 이용하였으며 cuda 9버전 기준이다. 또한 우분투환경에서도 잘 동작한다. ~_~

0. 만약 Anaconda 환경이 안깔려있으면 클릭, gpu버전을 셋팅한다. (제 그래픽 카드는 1080ti로 테스트 하였다)

1. Github에 들어가서 코드를 다운받는다.

2. anaconda 명령 프롬프트를 열어 가상화를 만들어준다. ex) conda create -n retinanet python=3.6 -> conda activate retinanet

3. keras-retinanet-master 프로젝트 파일로 이동 후 ex) cd C:\Users\mekai\Project\keras-retinanet-master

python setup.py install 명령어를 통해 설치한다.

4. tf1.14 및 keras 2.24 버전 설치 ex) conda install tensorflow-gpu=1.14 / conda install keras=2.2.4

5. 위까지 설치가 잘 완료되었으면, 학습용 데이터셋을 만들어야한다.

총 2가지 (Annotation format, Class Mapping format) 파일이 필요한데 둘 다 확장자는 .csv 파일이다. 기본적인 학습용으로 만들어보기에, 자동차(아반떼, k3)를 검출을 해보자.

fig1

Annotation format은 fig1 처럼 각 이미지의 경로와 x1,y1,x2,y2가 필요하며, 전체적으로는

Annotation format 형식 : (img path, x1, y1, x2, y2, class_name) 으로 csv가 저장되어야 한다.

annotation.csv

Classmapping format은 annotation에 class_name을 숫자로 mapping 시켜준 csv 파일이다.

Classmapping format 형식 : (class_name, number)

classmapping.csv

6. 이제 학습을 해보자!

train_data 폴더를 하나 만들어서 그 안에, data(.jpg/.png) 및 (annotation,classmapping).csv 파일을 넣어뒀다.

python keras_retinanet/bin/train.py --gpu=0 --epochs=10 --steps=1000 --workers=0 csv train_data/annotation.csv train_data/classmapping.csv

위 명령어를 입력하면 학습이 진행된다.

혹시나 ModuleNotFoundError: No module named 'keras_retinanet.utils.compute_overlap' 라는 오류가 발생한다면, python setup.py build_ext --inplace 명령어를 통해 해결할 수 있다.

7. 테스트 및 평가

테스트및 평가를 위해서는 학습된 모델을 convert해서 inference model로 바꿔줘야 한다.

python keras_retinanet/bin/convert_model.py ../snapshots/resnet50_csv_02.h5 ../snapshots/resnet50_csv_10_infer.h5

마지막으로 저장된 모델을 불러서 평가하면 끝~!

혹여나... 라벨툴을 알아보고 싶으면 클릭

python으로 시작하는 OpenCV (3)

미카이 — Thu, 6 Feb 2020 00:41:46 +0900

저번에 이에서 필터를 계속해서 알아보자.

sobel fileter

sobel filter는 3*3 이미지 필터를 사용하여 중심을 기준으로 각 방향의 앞뒤의 값을 비교해 변화량을 검출하는 알고리즘인데, 이미지 경사도의 계산방법이다.

예제를 통해 한번 알아보자.

import cv2

import numpy as np

import matplotlib.pyplot as plt

origin_img = cv2.imread('image.jpg', 0) # gray scale

# Sobel filter

dx = cv2.Sobel(origin_img, cv2.CV_32F, 1, 0)

dy = cv2.Sobel(origin_img, cv2.CV_32F, 0, 1)

#visualization

plt.figure(figsize=(8,3))

plt.subplot(131)

plt.axis('off')

plt.title('origin_img')

plt.imshow(origin_img, cmap='gray')

plt.subplot(132)

plt.axis('off')

plt.imshow(dx, cmap='gray')

plt.title(r'$\frac{dI}{dx}$')

plt.subplot(133)

plt.axis('off')

plt.title(r'$\frac{dI}{dy}$')

plt.imshow(dy, cmap='gray')

plt.tight_layout()

plt.show()

Colored by Color Scripter

위 코드의 결과를 보면 아래와 같은 결과가 나온다.

sobel filter result

dx dy

-1 0 1 -1 -2 -1

-2 0 2 0 0 0

-1 0 1 1 2 1

내용의 잠깐하게 살펴보면, cv2.Sobel 함수는 지정된 크기의 선형 필터를 사용해 이미지 경사도의 근삿값을 계산하는데, 사용될 필터와, 이미지의 데이터 타입이 계산돼야 할 미분 값을 지정할 수 있고, 행렬의 곱형태가 아닌 각 위치의 값들끼리 곱하고 모두 더한 값입니다.

Gabor filter

가버 필터는 코사인파로 변화된 2D 가우시안 커널을 갖는 선형 필터인데, 외곽선을 검출하는 기능을 가지고 있고, 쉽게 생각하면 사인,코사인 함수로 모듈화된 가우시안 필터라고 생각할 수 있다. (여기서는 필터, 커널 같은 용어로 사용할 것이다.)

예제를 한번 알아보자.

import cv2

import numpy as np

import matplotlib.pyplot as plt

import math

origin_img = cv2.imread('image.jpg', 0).astype(np.float32) # gray scale

origin_img = origin_img / 255

# Garbor filter form

kernel = cv2.getGaborKernel((21,21), 5, 1, 10, 1, 0, cv2.CV_32F)

kernel /= math.sqrt((kernel * kernel).sum())

filtered = cv2.filter2D(origin_img, -1, kernel)

plt.figure(figsize=(8,3))

plt.subplot(131)

plt.axis('off')

plt.title('origin_img')

plt.imshow(origin_img, cmap='gray')

plt.subplot(132)

plt.axis('off')

plt.imshow(kernel, cmap='gray')

plt.title('kernel')

plt.subplot(133)

plt.axis('off')

plt.title('filtered')

plt.imshow(filtered, cmap='gray')

plt.tight_layout()

plt.show()

Colored by Color Scripter

결과는 아래와 같다.

gabor filter result

수식은 위키피디아에서 확인 가능하다 : 클릭

예제를 간단하게 살펴보면, cv2.getGaborKernel() 함수는 [커널크기,가우시안 표준편차, 파형 방향, 파형 길이, 공간 비율, 위상] 형태를 매개변수로 받고, 이미지의 방향을 아는 경우 에지를 검출하는 데 유용한 필터이다.

discreate Fourier transform (DFT)

이산 푸리에 변환은말 그대로 이산적인 입력 신호에 대한 푸리에 변환으로 보통 신호처리 쪽에서 많이 사용되지만, 이미지를 공간 표현에서 주파수 표현으로 변환하고, 다시 역으로 변환하는 방법에도 이용한다.

예제를 한번 알아보자.

import cv2

import numpy as np

import matplotlib.pyplot as plt

origin_img = cv2.imread('image.jpg', 0).astype(np.float32) # gray scale

origin_img = origin_img / 255

# DFT

fft = cv2.dft(origin_img, flags=cv2.DFT_COMPLEX_OUTPUT)

# spectrum visualization

shifted = np.fft.fftshift(fft, axes=[0,1])

magnitude = cv2.magnitude(shifted[:,:,0], shifted[:,:,1])

magnitude = np.log(magnitude)

plt.figure(figsize=(8,2))

plt.subplot(131)

plt.axis('off')

plt.title('origin_img')

plt.imshow(origin_img, cmap='gray')

plt.subplot(132)

plt.axis('off')

plt.title('magnitude')

plt.imshow(magnitude, cmap='gray')

plt.tight_layout()

Colored by Color Scripter

결과는 다음과 같다.

DFT result

이번에도 코드를 간단히 살펴보면, cv2.dft2() 함수는 이산 푸리에 변환을 연산하는 함수 출력이 실수인지 복소수인지를 결정하기 위해 두가지 플래그 선택이 가능하다 (cv2.DFT_REAL_OUTPUT, cv2.DFT_COMPLEX_OUTPUT) / 만약 주파수 스펙트럼에서 공간 표현으로 변환하려면, restore = cv2.idft(fft, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT) 를 사용하면되는데, idft 함수는 고속 푸리에 변환 알고리즘을 사용한다. 그리고 np.fft.fftshift 함수는 주파수가 0에 해당하는 진폭 배열의 중심으로 이동하도록 스펙트럼을 이동시켜 해석이 간단해질 수 있다.

image threshold

이미지 임계 처리를 통해 다양한 작업을 할 수 있는데, 이번 예제에서는 흑백 이미지를 이진 이미지로 변환하는 방ㅂ버이다.

예제를 한번 알아보자.

import cv2

import numpy as np

import matplotlib.pyplot as plt

origin_img = cv2.imread('image.jpg', 0) # gray scale

#origin_img = origin_img / 255

# basic threshold

threshold, mask = cv2.threshold(origin_img, 200, 1, cv2.THRESH_BINARY)

print('값: ', threshold)

# adapt threshold

adapt_mask = cv2.adaptiveThreshold(origin_img, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY_INV, 11, 10)

# visualization

plt.figure(figsize=(10,3))

plt.subplot(131)

plt.axis('off')

plt.title('origin_img')

plt.imshow(origin_img, cmap='gray')

plt.subplot(132)

plt.axis('off')

plt.title('binary threshold')

plt.imshow(mask, cmap='gray')

plt.subplot(133)

plt.axis('off')

plt.title('adaptive threshold')

plt.imshow(adapt_mask, cmap='gray')

plt.tight_layout()

plt.show()

Colored by Color Scripter

결과

threshold result

예제코드를 간단하게 살펴보자,

threshold 처리는 크게 모든 픽셀에 동일한 임계값을 적용할 수 있는 local방식이 있고, 픽셀에 따라 적용하는 threshold값이 다른 adapt 방식이 있다.

cv2.threshold() 함수는 모든 픽셀에 동일한 임계값을 적용하는데, 임계값 type이 cv2.THRESH_BINARY, cv2.THRESH_BINARY_INV 등 있다. 자세한건 document를 보자.

반면에 cv2.adaptiveThreshold() 함수는 각 픽셀은 주변 픽셀 값에 따라 독자적인 임계값을 가지는데, cv2.ADAPTIVE_THRESH_MEAN_C 방식은 주변 픽셀의 평균에 사용자가 지정한 편향 값 (위 코드는 10)을 뺀 값을 픽셀 단위의 임계값으로 사용했다.

refer : openCV를 이용한 컴퓨터 비전학습, opencv document

python으로 시작하는 OpenCV (2)

미카이 — Tue, 4 Feb 2020 00:42:06 +0900

저번 포스팅에서는 입출력과 관련된 내용을 다뤄봤다면,

이번에는 행렬조작과 색 공간 및 필터에 대해 알아보자.

행렬 조작 : 생성하고 채우고, 요소 접근하고 ROI(Region of Interest)

import cv2

import numpy as np

img = np.full((480, 640,3), 255, np.uint8)

#img = np.full((480, 640,3), (0, 255, 0), np.uint8) # green

#img = np.full((480, 640,3), (0, 255, 255), np.uint8) # yellow

#img = np.full((480, 640,3), (0, 0, 255), np.uint8) # red

cv2.imshow('white img', img)

cv2.waitKey()

cv2.destroyAllWindows()

위와 같은 코드를 통해 특정 형태 (480,640,3) height,width,channel 형식으로 full (255)로 가득찬 이미지를 만들수 있다.

실행해보면 흰색 배경의 이미지가 만들어 질것이다.

그 외에도, 다양한 색 조합을 통해 ex) (255,255,0) 하늘색 -> 조절하면 색상을 조절 할 수 있다(0~255). 0을 채우면 black이미지가 만들어진다.

OpenCV의 파이썬 행렬은 Numpy 배열로 나타내며, 다차원 행렬(tensor)를 다루는 도구를 제공한다.

또한, 행렬은 일반적으로 너비, 높이, 채널 수의 세 가지 공간 차원을 갖는다. OpenCV는 컬러 또는 grayscale 행렬로 동작하지만 imread('path' ,-1) 를 통해 원본응로 읽어 올수도 있지만, 일반적인 형태는 두가지가 대표적이다.

RGB 표현을 위해 BGR 형식으로 저장하기 때문에 색 변경이나 이러한 부분에서 주의가 필요하다.

마지막으로 uint8로 보통 0~255로 저장하지만 np.float32나 np.float64로 값을 저장할 수도 있다.

이전에는 cv2.imread나 cv2.imwrite 함수를 이용하여 이미지만 저장하거나 불러왔다. 하지만 Numpy를 사용한 비이미지 데이터 속성으로 이미지뿐만 아니라 어떠한 형태나 데이터 타입의 행렬 또한 저장이 가능하다.

import cv2

import numpy as np

mat = np.random.rand(100, 100).astype(np.float32)

print(f'Shape : {mat.shape}') # (100,100) ->np.ndarray타입

print(f'Data Type : {mat.dtype}') # flaot32

np.savetxt('mat.csv', mat) # save numpy data

mat = np.loadtxt('mat.csv').astype(np.float32) # load data

위 코드를 간략하게 살펴보면, rand으로 100,100 크기의 float32 형태의 행렬을 만들고, np.savetxt() 함수를 통해 csv 형태로 저장한다. csv는 ,(쉼표) 로 구분된 데이터다. 또한 np.loadtxt() 함수를 통해 불러올 수 있으며, astype으로 타입변경도 가능하다!

만약 어떤 이미지를 불러오고 red 채널과 blue 채널을 바꾸고 싶다면, 아래 코드로 간단하게 바꿀 수 있다.

import cv2

import numpy as np

origin_img = cv2.imread('image.jpg')

img = origin_img.copy()

img[:, :, [0, 2]] = img [:, :, [2, 0]]

cv2.imshow('origin', origin_img)

cv2.imshow('blue_red_swapped', img)

cv2.waitKey()

cv2.destroyAllWindows()

채널 변경 결과

이번에는 색 공간 변환을 해보자.

기본적으로 openCV의 컬러 이미지는 RGB색 공간으로 표시된다. 그러나 가끔 다른 색 표현으로 변경해야 할 필요가 있는데, 예를 들면 강도(intensity)에 대한 별도의 채널을 갖는 경우가 있는데 한번 변경해보자.

import cv2

import numpy as np

origin_img = cv2.imread('image.jpg').astype(np.float32) / 255

gray_img = origin_img.copy()

hsv_img = origin_img.copy()

gray_img = cv2.cvtColor(gray_img, cv2.COLOR_BGR2GRAY)

hsv_img = cv2.cvtColor(hsv_img, cv2.COLOR_BGR2HSV)

cv2.imshow('origin_img', origin_img)

cv2.imshow('gray_img', gray_img)

cv2.imshow('hsv_img', hsv_img)

cv2.waitKey()

cv2.destroyAllWindows()

Colored by Color Scripter

위 코드를 간략하게 살펴보면 이미지를 normalization을 통해 불러오고, grayscale 사진 및 HSV 형태로 변경 시킨다.

cv2.cvtColor() 함수를 사용하면 간단하게 변경이 가능한데, 200가지가 넘는 유형을 지원하므로 궁금하면 document..

이미지를 다룰때면 픽셀 값의 통계적 값으로 설정해야 할 때가 있다. 값들의 평균값을 0으로 설정하고 분산을 1로 설정하면 이 연산은 정규화되는데, 분석이나 전처리 단계에서 유용하게 사용되며

img = img = cv2.imread('image.jpg').astype(np.float32) / 255
img = img - img.mean()
img = img / img.std()

3줄로 간단하게 정규화 할 수 있는데 간단하게 살펴보면, mean을 통해 평균을 빼주고 다시 표준편차로 나눠준다.

그 외에도 cv2.meanStdDev를 이용하면 평균과 표준 편차를 동시에 계산도 가능하다.

이미지 히스토그램은 값의 집합에 대한 분포 수준을 보여주고, 어떤 값으로 치우져 있거나 outlier를 제거하기 위한 지표로도 사용이 가능하다.

import cv2

import numpy as np

import matplotlib.pyplot as plt

img = cv2.imread('image.jpg',0)

hist, bins = np.histogram(img, 256, [0,255])

plt.fill(hist)

plt.xlabel('pixel value')

plt.show()

Colored by Color Scripter

위 코드에서 cv2.calcHist함수가 제공되지만, 코드 간결성을 위해 numpy에서 제공되는 np.histogram()함수를 이용하였다. 이 함수는 (입력 이미지, bin의 수, bin의 범위) 값과 에지 값을 배열로 반환한다.

image histogram

하지만 이미지 히스토그램을 사용하다보면 대비가 낮은 이미지는 대부분 픽셀 값의 범위가 좁기 때문에 특정 값으로 군집되는 히스토그램을 갖는데, 히스토그램 평활화를 통해 세부적인 부분을 표현 할 수 있다.

import cv2

import numpy as np

import matplotlib.pyplot as plt

img = cv2.imread('image.jpg',0)

hist_equal= cv2.equalizeHist(img)

hist, bins = np.histogram(hist_equal, 256, [0,255])

plt.pill_between(range(256), hist, 0)

plt.xlabel('pixel value')

plt.show()

Colored by Color Scripter

histogram equalization

마지막으로 노이즈 제거를 간략하게 알아보자.

모든 real world이미지에는 많은 노이즈가 포함돼 있다. 노이즈는 이미지의 형태를 망치고, 전처리하기에도 좋지 않은 영향을 준다 그래서 노이즈를 제거하거나 감소시키는 방법을 알아보자.

noise 추가된 이미지

위 사진 처럼 이미지에 노이즈를 추가해보고 gaussian_blur median_blur 를 이용해서 보자.

import cv2

import numpy as np

import matplotlib.pyplot as plt

# [0, 1] 사이의 범위의 부동소수점 데이터 타입으로 변환

img = cv2.imread('image.jpg').astype(np.float32) / 255

# noise 추가

noise = (img + 0.2 * np.random.rand(*img.shape).astype(np.float32))

gauss_blur = cv2.GaussianBlur(noise, (7, 7), 0)

median_blur = cv2.medianBlur((noise * 255).astype(np.uint8),7)

noise = noise.clip(0, 1)

plt.imshow(noise[:, :, [2,1,0]])

plt.imshow(gauss_blur [:, :, [2,1,0]])

plt.imshow(median_blur[:, :, [2,1,0]])

plt.show()

Colored by Color Scripter

위 코드도 간략하게 살펴보면 가우시안 필터를 적용하기 위해 cv2.GaussianBlur 함수를 사용하는데, (img, kernel(width,height)) 형태로 파라미터를 갖는데 다양하게 파라미터를 조절하면서 만지작 거리다보면 뭔가 최적으로 noise를 줄일 수 있지 않을까? 생각이 든다.

reference

book : 파이썬과 OpenCV를 이용한 컴퓨터 비전 학습

document : python opencv document

python으로 시작하는 OpenCV (1)

미카이 — Sun, 2 Feb 2020 20:35:11 +0900

컴퓨터 비전은 우리가 눈으로 보는것처럼 컴퓨터에 시각을 부여해 이미지를 분석함으로써 유용한 정보를 생성하는 기술이다. 컴퓨터 로봇 등을 통해 얼굴, 건물, 의료 등의 다양한 도움을 준다. 또한 인공지능 기술이 발전하면서 인식, 검출, 분할 등 기술의 진화 속도가 엄청나께 빠르게 발전하고 있다.

개인적인 공부를 통해 최종적으로는 SLAM(simultaneous localization and mapping) 기술을 습득하는것을 목표로 한다.

또한, 간단한 기본 예제부터 좀 더 심화된 예제를 다뤄보면서 기본기를 익히면서 진행하고 복습차원에서 블로그로 내용을 정리한다.

window or ubuntu 환경을 이용하고 conda 환경을 통해 실습을 진행할 예정이다.

설치는 conda propmt에서 pip install opencv-contrib-python or pip install opencv-python 으로 간단하게 설치가 가능하다.

첫번째로 다뤄볼 내용은 입출력 기능과 관련된 기본적인 OpenCV 기능을 다뤄본다.

1. 파일에서 이미지 읽어오기

아무 이미지나 가져와서 읽어본다.

여기서는 대표적인 rena이미지를 출력해보겠다.

ex)

# gui_opencv.py

import argparse

import cv2

parser = argparse.ArgumentParser()

parser.add_argument('--path', default='image.jpg', help='Image path.')

params = parser.parse_args()

img = cv2.imread(params.path)

assert img is not None # 로딩 제대로 된지 확인

cv2.imshow('window', img)

cv2.waitKey(0) # 아무키나 입력 받기전까지 대기하고 입력받으면 window창 종료
cv2.destroyAllWindows()

print(f'read {params.path}') #read image.jpg

print(f'shape :{img.shape}') # shape :(225, 225, 3)

print(f'dtype :{img.dtype}') # dtype :unint8

# print('read {}'.format(params.path)) or print('read ', params.path) 로 출력이 가능한데, 가독성을 위해 위와 같이 표현한다.

만약 prompt를 이용해서 실행하시는 분이라면 해당 프로젝트 파일안에, image파일이 있으신 분은 아무값도 없이 넣어도 되지만 아니라면 절대경로나 상대경로를 argument 값으로 실행시키면 된다.

ex) python gui_opencv.py --path 'images.jpg' # ''안에 이미지 경로를 넣어주면 된다.

간단하지만 코드를 살펴보자면, imread 함수를 살펴보면 선택적 플래그도 지원하며, uint8(unsigned 8) 타입으로 변환 등 다양한 형태를 지정할 수 있다.

cv2.imread('path', 0) # grayscale, 1은 color, -1은 원본 그대로 ~_~ 만약 뒤에 인자값을 안준다면 기본 디폴트로 3채널(color)로 읽게 된다.

또한, (height, width, channel) 형태의 numpy 형식으로 데이터를 읽어오며 , RGB 형식 대신에 BRG 형식으로 이미지를 로딩한다는 점을 기억하자.

2. Image Resize & Flip (이미지 사이즈 조절 및 뒤집기)

resize_flip

위 이미지와 같이 원본 이미지를 resize하거나, flip하는것도 간단하게 구현이 가능하다.

# resize_flip_basic.py

import cv2

width, height = 455, 455

img = cv2.imread('image.jpg')

resized_img = cv2.resize(img, (width, height))

cv2.imshow('resize_img', resized_img)

flip_img = cv2.flip(img, 0)

cv2.imshow('flip_img', flip_img)

cv2.waitKey(0) # 아무키나 입력 받기전까지 대기하고 입력받으면 window창 종료

cv2.destroyAllWindows()

위 내용도 간단하게 살펴보면

cv2.resize 함수는 뒤 매개변수로 (width, height)를 줘서 픽셀 단위로 설정을 할 수 있고, 이미지의 원본 너비와 높에 대한 배수를 설정해서 크기를 조정할 수 있다

ex) cv2.resize(img, (0,0), img, 0.25, 0.5) # width로 0.25 쭐이고 height로 반 줄인다.

cv2.flip 함수는 뒤 매개변수로 0을 주면 x축을 따라 뒤집고, 1이면 y축을 따라 이미지를 뒤집고, -1이면 x,y축 동시에 뒤집는다.

3. Image Write (이미지 저장)

# write_basic.py

import cv2

img = cv2.imread('image.jpg')

cv2.imwrite('img_compressed.png', img, [cv2.IMWRITE_PNG_COMPRESSION, 0]) # 낮은 압축률로 이미지 저장

cv2.imwrite('img_compressed2.jpg', img, [cv2.IMWRITE_JPEG_QUALITY, 0]) # jpg 형식으로 저장 저화질로 저장된걸 확인할 수 있다.

save_img = cv2.imread('img_compressed.png')

assert save_img.all() == img.all() # 원본과 동일한지 비교

save_img2 = cv2.imread('img_compressed.jpg')

assert save_img2.all() == img.all() # 원본과 동일한지 비교 오류 발생!

Colored by Color Scripter

보통 우리가 이미지를 저장할때,

cv2.imwrite('path', img) 이런식으로 저장하는데 압축수준이라던지 퀄리티 인자값을 통해 이미지를 저장할 수 있다.

COMPRESSION은 (0,9) 사이의 값을 갖고, 숫자가 클수록 파일 크기는 작지만, 디코딩 프로세스가 느려진다.

QUALITY는 (0,100) 사이의 값으로 설정할 수 있고 값이 클수록 좋은 품질을 의미하므로 큰 값이면 artifact양이 감소한다.

그 외에도, 비디오, 프리미티브, 등 다양한 GUI환경을 지원한다.

다음 챕터로는 행렬, 색상, 필터를 알아보자!!

reference

book : 파이썬과 OpenCV를 이용한 컴퓨터 비전 학습

document : python opencv document

Pytorch 1.1.0 / Tensorflow-gpu 1.12 설치 및 cuda10_9 확인

미카이 — Thu, 9 Jan 2020 13:38:27 +0900

Pytorch 1.1.0 version

# CUDA 9.0

conda install pytorch==1.1.0 torchvision==0.3.0 cudatoolkit=9.0 -c pytorch

# CUDA 10.0

conda install pytorch==1.1.0 torchvision==0.3.0 cudatoolkit=10.0 -c pytorch

# CPU Only

conda install pytorch-cpu==1.1.0 torchvision-cpu==0.3.0 cpuonly -c pytorch

Tensorflow-gpu 1.12.0 version

conda install tensorflow-gpu=1.12

위 명령어로 설치할 수 있으며,

cuda 9.0버전을 사용하며,

python version은 3.6.9를 사용한다.

cuda 9.0cuda_9.0.176_win10 을 다운받았으며,

cudnn은 cudnn-9.0-windows10-x64-v7.3.1.20 이 가장 잘 어울리고 오류없이 작동하는것을 확인하였다.

https://developer.nvidia.com/cuda-toolkit-archive -> cuda 설치

https://developer.nvidia.com/rdp/cudnn-archive -> cudnn 설치

이렇게 설치하니 gpu로 잘 동작되는것을 확인하였다.

gpu 동작확인은 클릭

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

번외로

요즘 Tensorflow 2.0 버전을 많이 사용하는데,

내가 사용하는 cuda10은 아래와 같다

Tensorflow 2.0 설치

pip install tensorflow-gpu==2.0

위 명령어로 설치할 수 있으며,

cuda 10.0버전을 사용하며,

python version은 3.6.9를 사용한다.

cuda_10.0.130_411.31_win10 을 다운받았으며,

cudnn은 cudnn-10.0-windows10-x64-v7.6.0.64 이 가장 잘 어울리고 오류없이 작동하는것을 확인하였다.

https://developer.nvidia.com/cuda-toolkit-archive -> cuda 설치

https://developer.nvidia.com/rdp/cudnn-archive -> cudnn 설치

cuda10.1 보단 10.0을 안전하게 설치하자 ~_~

시간 여유가 되면, cuda 10/9 설치해서 동시에 사용은 안되지만 path 잡아서 변경하는것을 포스팅하려한다...

이것때매 삽질을 많이했다 ㅠㅠ...

conda 환경으로 tensorflow gpu 2.0 / 1.x 버전 관리하기

미카이 — Wed, 13 Nov 2019 16:33:02 +0900

최근 tensorflow 2.0가 정식 릴리즈 되면서 많은 사람들이 2.0 버전으로 공부 및 연구를 시작한다.

하지만 이전 버전에서 작업했던 분들은 두가지 버전을 둘 다 사용해야되는 경우가 많아서(필자 또한) conda 환경으로 간단하게 두 가지 버전다 사용을 하는 방법을 포스팅 하고자 한다.

두가지 버전 설치가 잘 되었다면, 아래 그림과 같이 gpu 사용이 True라고 뜰 것이다.

tensorflow 2.0.0

tensorflow 1.11.0

기존의 tensorflow 1.x 버전이 깔려있다고 가정하고 진행하겠다.

Cuda 버전같은 경우는

tensorflow 1.x - cuda 9.0 / tensorflow 2.x - cuda 10.0 로 설치하였다.

anaconda 가 깔려있다고 가정하고 시작하겠다. (만약 설치가 되어있지 않다면 클릭)

1. visual studio 2017 버전 설치

https://docs.microsoft.com/ko-kr/visualstudio/releasenotes/vs2017-relnotes

Visual Studio 2017 15.9 릴리스 정보

Visual Studio 2017의 향상된 최신 기능에 대한 릴리스 정보입니다. Visual Studio를 사용하여 더 효과적으로 계획하고, 함께 코딩하여 빠르게 제공하세요.

docs.microsoft.com

위 주소로 들어가 download community 2017 버전을 깔면된다. 따로 설정은 필요없다. 만약 이전에 2019버전이 깔려있으면 삭제 후 진행한다.

2. 가상환경 만들기

나는 1.x 버전은 conda base 환경에서 사용하므로, 2.0 을 새로운 가상환경을 만들어서 사용한다.

아래 명령어를 통해 tensorflow2.0 이라는 이름으로 콘다 가상환경을 만들어준다. 이름은 자유자제로 만들어도 된다.

conda create --name tensorflow2.0 python=3.6

3. cuda 및 cudnn 설치

https://developer.nvidia.com/cuda-toolkit-archive

CUDA Toolkit Archive

Previous releases of the CUDA Toolkit, GPU Computing SDK, documentation and developer drivers can be found using the links below. Please select the release you want from the list below, and be sure to check www.nvidia.com/drivers for more recent production

developer.nvidia.com

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

cuDNN Archive

NVIDIA cuDNN is a GPU-accelerated library of primitives for deep neural networks.

developer.nvidia.com

위 두 페이지로 들어가서 cuda 10.0 을 다운받고, 설치 후 / cudnn 7.6.0 for cuda 10.0 을 클릭해서 맞은 운영체제에 맞게 cudnn 안에 있는 폴더를 cuda에 덮어씌운다.

4. tensorflow gpu 설치

conda activate tensorflow2.0 / 명령어를 통해 가상환경 활성화 한 후

(tensorflow2.0) pip install tensorflow-gpu==2.0.0 / (base)->(tensorflow2.0) 으로 바뀐지 확인 후 tensorflow gpu 설치

5. 설치 후 테스트

(tensorflow2.0) jupyter lab / 명령어를 통해 jupyter lab을 활성화 한 후 notebook파일 하나 만든 후

import tensorflow as tf
print(tf.__version__)
tf.test.is_gpu_available()

로 True가 되는 지 확인

True가 나온다면 설치 끝~ 이제 즐거운 딥러닝을 시작하면된다.

혹시나 다시 1.x 대로 작업하고 싶다면 conda deactivate 하면 (base) 로 돌아와서 다시 1.x로 작업할 수 있다.

ps)

conda install tensorflow-gpu==2.0.0 으로 설치해서 cuda도 잡아준다고해서 설치했는데 뭔가 오류가 뜨고 수정이 힘든부분이 있어, 그냥 pip 명령어로 설치하였다.

ref)

https://chan-lab.tistory.com/13

https://www.tensorflow.org/install/pip?lang=python3

python break, pass, continue 차이점

미카이 — Tue, 15 Oct 2019 17:44:09 +0900

파이썬으로 코딩을 하다보면 break문, pass문, continue 문이 자주 보인다.

헷갈리는 부분을 정리하고자 각 각 사용법과 예시를 통해 정리해본다.

break : 특정 반복문(while, for 문)에서 루프를 빠져나올때 이용하는데, 한번만 빠져나오게 된다. 이중 포문일때, 해당 루프만 탈출하고 다음껀 계속 반복되서 다시 또 다음루프를 들어갈 수 있다.

ex)

for i in range(3):
    print('탈출 준비')
    for j in range(3):
        print('탈출 하자')
        break

결과

탈출 준비
탈출 하자
탈출 준비
탈출 하자
탈출 준비
탈출 하자

위와같은 결과를 얻는데, 만약 i도는 루프를 탈출하고싶다면, 조건을 걸어서 탈출할 수 있다.

ex)

y = False
for i in range(3):
    if y:
        break

    print('탈출 준비')
    for j in range(3):
        print('탈출 하자')
        y = True
        break

결과

탈출 준비
탈출 하자

pass : 단순하게 실행할 코드가 없다는 것을 의미한다.

ex)
for i in a:
    if i == 3:
        print(i)
        pass
    print('pass')

결과

3
pass
pass
pass

continue : 강제로 다음 loop를 돌게 하는 것을 의미

ex)

a = [3,6,9]
for i in a:
    if i == 3:
        print(i)
        continue
    print('pass')

결과

3
pass
pass

OpenCV를 이용한 Yolo v3 적용하기

미카이 — Sun, 13 Oct 2019 00:02:40 +0900

개인적인 공부 개념으로 저장해두는 공간입니다.

원본글을 기반으로 만들었습니다. 문제가 되면 지우도록 하겠습니다.

https://pysource.com/2019/06/27/yolo-object-detection-using-opencv-with-python/

YOLO object detection using Opencv with Python - Pysource

We’re going to learn in this tutorial YOLO object detection. Yolo is a deep learning algorythm which came out on may 2016 and it became quickly so popular because it’s so fast compared with the previous deep learning algorythm. With yolo we can detect obje

pysource.com

darknet을 많이 이욯해서 keras나 tensorflow에서 많이 사용하겠지만,

opencv에서도 간편하게 사용할 수 있는 방법이 있어서 정리하려고 합니다.

여기 예제에서는, yolov3-320 pre-trained된 모델을 이용하기 때문에, weight파일과 cfg 파일을 다운받아야 한다. 다운

원본 테스트이미지는 다음과 같습니다.

원본

yolov3 모델같은 경우는 coco dataset기준으로 학습이 되어 있으므로, 80개 종류를 디텍션 할 수 있다.

만약 원하면 커스텀 데이터에 대해서도 학습할 수 있다.

classes = ["person", "bicycle", "car", "motorcycle",
            "airplane", "bus", "train", "truck", "boat", "traffic light", "fire hydrant",
            "stop sign", "parking meter", "bench", "bird", "cat", "dog", "horse",
            "sheep", "cow", "elephant", "bear", "zebra", "giraffe", "backpack",
            "umbrella", "handbag", "tie", "suitcase", "frisbee", "skis",
            "snowboard", "sports ball", "kite", "baseball bat", "baseball glove", "skateboard",
            "surfboard", "tennis racket", "bottle", "wine glass", "cup", "fork", "knife",
            "spoon", "bowl", "banana", "apple", "sandwich", "orange", "broccoli", "carrot", "hot dog",
            "pizza", "donut", "cake", "chair", "couch", "potted plant", "bed", "dining table",
            "toilet", "tv", "laptop", "mouse", "remote", "keyboard",
            "cell phone", "microwave", "oven", "toaster", "sink", "refrigerator",
            "book", "clock", "vase", "scissors", "teddy bear", "hair drier", "toothbrush" ]

특히, 몇줄 안되는 코드로 테스트 결과를 확인할 수 있었으며,

net = cv2.dnn.readNet("yolov3.weights", "yolov3.cfg") 이런식으로 모델을 간편하게 불러올 수 있다.

또한, cv2.VideoCapture를 이용하면 real-time object detection도 간편하게 할 수 있다.

tiny버전을 받으면 생각보다 frame이 잘나온다.

result

생각보다 결과가 잘나오는 것을 확인할 수 있다.

전체 소스코드는 클릭 여기서 확인하거나 원본 글 클릭 에서 확인할 수 있다.

ImageAI 를 활용한 15줄짜리 object detection

미카이 — Mon, 7 Oct 2019 15:09:03 +0900

더욱 자세한 정보는

https://towardsdatascience.com/object-detection-with-10-lines-of-code-d6cb4d86f606

Object Detection with 10 lines of code

Part 2 of this tutorial for detecting your custom objects is available via this link.

towardsdatascience.com

여기 글을 참고해서 포스팅합니다.

문제가 생길시, 지우도록하겠습니다.

faster rcnn, yolo 등 다양한 오브젝트 디텍션 모델들이 나와있지만, 초보자가 사용하기가 힘든 문제점이 있다.

그래서 이번에는 아주 간단하지만 괜찮은 성능을 보여주는 간단한 코딩을 해볼 예정이다.

사전에 앞서,

실습환경: jupyter lab

version : python3.7, keras, tensorflow, matplot, imageai 모듈이 깔려있다고 가정한다.

ImageAI는 pip install imageai 명령어를 통해 간편하게 설치할 수 있다.

또한 실습에 필요한 pre-trained 된 모델은 retinanet을 이용하였으며, link< 여기서 받을 수 있다.

원본

디텍션 결과

위 그림처럼 결과를 얻을 수 있으며, 아마 coco dataset기반으로 pretrained 된 모델이니 디텍션 결과 종류를 얻을 수 있을 것이다.

그리고 조금만 수정한다면 실시간으로 처리하고 하는 부분도 가능할꺼같다.

전체소스 코드

import numpy as np

import matplotlib.pyplot as plt

from matplotlib.image import imread

from imageai.Detection import ObjectDetection

import os

detector = ObjectDetection()

detector.setModelTypeAsRetinaNet()

detector.setModelPath("model/resnet50_coco_best_v2.0.1.h5")

detector.loadModel()

detections = detector.detectObjectsFromImage(input_image="input_images/image.jpg",

output_image_path="output_images/image.jpg")

for eachObject in detections:

print(eachObject["name"] , " : " , eachObject["percentage_probability"] )

img = imread('output_images/image.jpg')

plt.imshow(img)

Colored by Color Scripter

만약 coco dataset 처럼 custom 데이터와 위치정보 라벨된 데이터셋이 있어서 학습을 시키고 싶다면,

아래 코드로 간편하게 학습도 가능한거 같다.

결국 데이터가 ..ㅠ

https://medium.com/deepquestai/train-object-detection-ai-with-6-lines-of-code-6d087063f6ff

Train Object Detection AI with 6 lines of code

Step-by-step tutorial on training object detection models on your own dataset

medium.com