whatisworth 님의 블로그

가정용 AI 개발 환경 만들기 2탄 - 생성한 AWS 인스턴스 관리하기

whatisworth — Fri, 11 Apr 2025 21:59:04 +0900

앞선 글에서 AWS에서 나만의 개발환경을 만드는 법에 대해서 기술했었다.

가정용 AI 개발 환경 만들기 1탄 - AWS 인스턴스 생성

집에 고사양의 GPU가 있다면 너무 좋겠으나, 비용상의 이유나 환경상의 이유로 GPU를 구매하기 어려운 경우가 많다.. 사실 기업도 고사양의 GPU서버를 사용하기보다는 AWS 나 Azure 같은 클라우드 서

whatisworth.tistory.com

그런데!! 모두가 알고 있겠지만, AWS에서 사용하는 GPU나 SSD를 사용하는 것은 과금이 되는,, 유료서비스라는 것..!

따라서 우리의 소중한 돈이 쓸데없이 나가는 것을 방지하기 위해서는.. 인스턴스를 관리하는 방법도 알아야한다..ㅠㅠ

1. 헷갈리는 AWS 개념 정리

먼저, 여러가지 용어들을 이해할 필요성이 있다. 자주 나오는 용어 위주로 정리해보았다.

용어	정의	예시
EC2	AWS의 가상 컴퓨터 서비스	아마존 클라우드에 있는 컴퓨터 본체
인스턴스	EC2 서비스로 만든 실제 실행 중인 가상 컴퓨터	EC2란 공장에서 찍언앤 나만의 컴퓨터 한대
EBS	EC2 인스턴스에 붙는 SSD 하드 디스크	컴퓨터에 꽂힌 C드라이브 같은것
스냅샷	EBS 디스크의 정지된 사진(백업본)	하드 디스크의 복사본

즉, 아마존 본체(EC2)에서 나만의 컴퓨터(인스턴스)를 저장 장치(EBS)까지 해서 사용자가 사용할 수 있도록 공장에서 나오는것이라고 생각하면 된다!

2. 과금 비용 관리하기

기본적으로 AWS 클라우드 서비스 사용시에 과금이 되는 point는 다음과 같다.

종류	설명	예시
네트워크	EC2에서 외부로 나가는 트래픽도 과금 대상이다.	apt update, docker pulll, wget 등 모델 다운로드나 패키지 다운로드 시
스토리지	저장 공간 사용료	루트 디스크(EBS), 스냅샷
컴퓨팅	GPU 인스턴스로 연산시 시간 단위 과금	AI 모델 학습 혹은 추론시

일반적으로 인공지능 모델을 학습시킬 때, 우리는 데이터나 모델 weight파일 등을 저장시킬 SSD가 필요하고, 연산에 필요한 GPU가 필요하다. 또한 외부에서 각종 패키지들을 다운로드 하기 위하여 인터넷 연결이 필요하다.

AWS에서는 영리하게도 이러한 요소들을 다 파악해서 요금을 설정해놓은 것으로 보인다 ㅎㅎ

3. 비용 줄이기 꿀팁

네트워크 : 모델, 패키지, 도커 이미지 캐시 등을 미리 로컬에 백업해놓기
스토리지 : 나는 개인적으로 모든 EC2 사용후에는 항상 볼륨을 스냅샷으로 백업해놓고, 볼륨을 인스턴스에서 분리한 뒤 지우는 방법으로 관리하고 있다.
인스턴스 : 안쓸땐 항상 중지시켜놓는다. (아예 삭제 하지 않고 중지만 해놓아도 과금되지 않기 때문)

4. 결제창으로 청구 비용 예상해보기

AWS 홈페이지에서 과금 정보 및 비용 관리 > 청구서 항목으로 들어가면 다음과 같이 나의 요금을 항목별로 자세히 볼 수 있다.

[논문 구현] U-Net 구현하기 1탄 - 학습 코드 짜기

whatisworth — Wed, 9 Apr 2025 22:26:01 +0900

논문도 다 읽었으니 UNet 을 직접 pytorch로 구현해보는 실습을 해볼것이다..!

예전에 작성했던 논문 리뷰 링크!

[논문 리뷰] U-Net 꼼꼼한 리뷰

AbstractDeep Neural Network의 성공적인 학습을 위해서는 많은 양의 annotated training sample들이 필요하다.이 paper에서는 annotated sample들을 더욱더 효율적으로 활용하기 위하여 Data augmentation기반의 새로운 ne

whatisworth.tistory.com

추론하는 코드를 짤때는 사용자가 직접 테스트 해볼 수 있도록 streamlit 같은 시각화 도구를 사용하여 데모페이지도 한번 만들어보려고 하는 계획을 가지고 있다 ㅎㅎ

나는 항상 코딩할때 구조부터 짜고 들어간다. 안그러면 코드가 정신없어져서 스파게티 코드가 되어버리기 때문에..ㅎ.ㅎ

1. 코드 구조

.
├── README.md
├── configs
│   └── config.yaml
├── input
├── main.py
├── model
│   └── unet.py
├── output
├── requirements.txt
├── utils
└── weights

configs : 학습한 weight 경로, 데이터 경로 등 각종 파라미터 저장용
input : 학습 데이터 저장 경로
main.py : 추론코드
model : 모델 구조
output : 모델이 추론한 결과물들 모아놓는 곳
requirements.txt : 각종 패키지 설치용
utils : 각종 시각화,, 기타 잡다한 것들
weights : 학습한 weight 저장 경로

2. 모델 구조 짜기

(1) Contracting Path

첫번째로 해야할 것은 모델의 구조를 짜는 것이다.

먼저 contracting path, 즉 U-net 구조에서 압축하는 부분을 짤건데 요 부분 같은 경우는 3x3 convolution + relu 가 2번 반복적으로 나타나기 때문에 하나의 block으로 짜주면 보기에 좋다.

또, 아무래도 반복적인 패턴이 있기 때문에, Sequential 을 사용하여 짜주면 구조화 하는데 좋다!

class ConvolutionBlock(nn.Module):
    def __init__(self, in_channels, out_channels, padding=0, downsample=None):
        super().__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, padding),
            nn.BatchNorm2d(out_channels),
            nn.LeakyReLU(negative_slope=0.1),
            nn.Conv2d(out_channels, out_channels, padding),
            nn.BatchNorm2d(out_channels),
            nn.LeakyReLU(negative_slope=0.1)
        )

    def forward(self, x):
        out = self.conv(x)
        return out

그리고 UNet 모델 class에 윗부분을 추가해줄건데, 여기서 중요한 점!! 앞에서 짠 convolution block의 경우, "class"이기 때문에 UNet class에서 init에서 정의하지 않고 들어가버리면 학습이 이상하게 되어버린다

예를 들어,

class UNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.pool = nn.MaxPool2d(2,2)
    
    def forward(self, x):
        out = ConvolutionBlock(3, 64, padding=1)

이런 식으로 forward 함수 밑에 class로 정의한 block을 써버리게 되면 매번 클래스를 새로 인스턴스화 하기 때문에 올바른 학습이 되지 않는다.

따라서,

class UNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.pool = nn.MaxPool2d(2,2)
        self.down_conv1 = ConvolutionBlock(3, 64, padding=1)
    
    def forward(self, x):
        out = self.down_conv1(x)

이런식으로 init에서 먼저 초기화를 해준 후, 가져다 써야한다.

(2) skip connection

skip connection을 위해, contracting path 4번으로부터 나온 결과물을 각각 저장해준다. 이렇게!

def forward(self, x):
    x1 = self.down_conv1(x)
    x2 = self.down_conv2(self.pool(x1))
    x3 = self.down_conv3(self.pool(x2))
    x4 = self.down_conv4(self.pool(x3))

contracting path에서 skip connection으로 expansion path로부터 나온 결과물이랑 concatenate 시킬 때 사이즈가 안맞다... 이를테면 x4는 [1, 512, 64, 64] 인데, 합쳐야할 대상은 [1, 512, 56, 56]이다. 따라서 center crop 과정을 거쳐야한다.

# skip connection을 위한 center crop 
def center_crop(enc_feat, target_size):
    _, _, h, w = enc_feat.shape 
    th, tw = target_size 
    x1 = (w - tw) // 2
    y1 = (h - th) // 2
    return enc_feat[:, :, y1:y1+th, x1:x1+tw]

(3) expansion path

decoder 부분에 해당하는 expansion path는 특이하게 up convolution, 즉 합성곱 연산을 거꾸로 하는 연산이 필요하다.

pytorch nn에 기본적으로 잘 짜져있는 nn.ConvTranspose2d 를 사용한다.

self.up_transpose1 = nn.ConvTranspose2d(1024, 512, kernel_size=2, stride=2)

이런식으로 총 4개를 필터 사이즈에 맞춰서 작성해주면 된다!

그리고 그림에서 빨간색으로 표시된 부분은 앞서 작성한 convolution block과 구조가 같으므로 재사용해준다.

(4) final layer

final layer는 그림에서도 보다시피 1x1 conv layer를 통과시켜야한다. class 개수에 맞추어 다음과 같이 작성해준다.

self.final = nn.Conv2d(64, num_classes, kernel_size=1)

그럼 완성!!

전체 코드는 다음과 같다!

import torch 
import os 
from torch import nn 
from torch.utils.data import DataLoader 
from torchvision import datasets, transforms 

# GPU 장치 선언 
device = "cuda" if torch.cuda.is_available() else "cpu"
print(device)

# skip connection을 위한 center crop 
def center_crop(enc_feat, target_size):
    _, _, h, w = enc_feat.shape 
    th, tw = target_size 
    x1 = (w - tw) // 2
    y1 = (h - th) // 2
    return enc_feat[:, :, y1:y1+th, x1:x1+tw]

# convolution block 정의하기 - 3x3 conv + relu 2번
class ConvolutionBlock(nn.Module):
    def __init__(self, in_channels, out_channels, padding=0, kernel_size=3):
        super().__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, padding=padding),
            nn.BatchNorm2d(out_channels),
            nn.LeakyReLU(negative_slope=0.1),
            nn.Conv2d(out_channels, out_channels, kernel_size=kernel_size, padding=padding),
            nn.BatchNorm2d(out_channels),
            nn.LeakyReLU(negative_slope=0.1)
        )

    def forward(self, x):
        out = self.conv(x)
        return out
        
class UNet(nn.Module):
    def __init__(self, num_classes=1):
        super().__init__()
        self.pool = nn.MaxPool2d(2,2)
        self.down_conv1 = ConvolutionBlock(3, 64)
        self.down_conv2 = ConvolutionBlock(64, 128)
        self.down_conv3 = ConvolutionBlock(128, 256)
        self.down_conv4 = ConvolutionBlock(256, 512)
        self.down_conv5 = ConvolutionBlock(512, 1024)
        self.up_transpose1 = nn.ConvTranspose2d(1024, 512, kernel_size=2, stride=2)
        self.up_conv1 = ConvolutionBlock(1024, 512)
        self.up_transpose2 = nn.ConvTranspose2d(512, 256, kernel_size=2, stride=2)
        self.up_conv2 = ConvolutionBlock(512, 256)
        self.up_transpose3 = nn.ConvTranspose2d(256, 128, kernel_size=2, stride=2)
        self.up_conv3 = ConvolutionBlock(256, 128)
        self.up_transpose4 = nn.ConvTranspose2d(128, 64, kernel_size=2, stride=2)
        self.up_conv4 = ConvolutionBlock(128, 64)
        self.final = nn.Conv2d(64, num_classes, kernel_size=1)

    def forward(self, x):
        x1 = self.down_conv1(x)
        x2 = self.down_conv2(self.pool(x1))
        x3 = self.down_conv3(self.pool(x2))
        x4 = self.down_conv4(self.pool(x3))
        out = self.pool(x4)
        out = self.down_conv5(out)
        out = self.up_transpose1(out)
        out = torch.cat((out, center_crop(x4, out.shape[2:])),dim=1)
        out = self.up_conv1(out)
        out = self.up_transpose2(out)
        out = torch.cat((out, center_crop(x3, out.shape[2:])),dim=1)
        out = self.up_conv2(out)
        out = self.up_transpose3(out)
        out = torch.cat((out, center_crop(x2, out.shape[2:])),dim=1)
        out = self.up_conv3(out)
        out = self.up_transpose4(out)
        out = torch.cat((out, center_crop(x1, out.shape[2:])),dim=1)
        out = self.up_conv4(out)
        out = self.final(out)
        return out

가정용 AI 개발 환경 만들기 1탄 - AWS 인스턴스 생성

whatisworth — Sun, 6 Apr 2025 13:31:58 +0900

집에 고사양의 GPU가 있다면 너무 좋겠으나, 비용상의 이유나 환경상의 이유로 GPU를 구매하기 어려운 경우가 많다.. 사실 기업도 고사양의 GPU서버를 사용하기보다는 AWS 나 Azure 같은 클라우드 서비스를 이용하는 경우가 많기 때문에, AWS 인스턴스를 생성하는 방법을 알고 있다면 여러모로 도움이 될것 같아서 정리해보았다.. ㅎㅎ 그럼 시작!

1. AWS 계정 생성

https://aws.amazon.com/ 에 접속
무료로 가입하기
이메일 / 비밀 번호 / 사용자 이름 입력
개인 계정 선택
신용카드 or 체크 카드 등록 (해외 결제 카드 가능 카드 필요)
휴대폰 인증
무료 요금제 선택 (기본요금 덜 나가는 방법)
가입 완료 후 AWS Console 에 로그인한다. (루트 사용자로 로그인해야함!)

2. EC2로 GPU 인스턴스 생성

리전을 미국(버지니아 북부)로 선택 후 EC2 대시보드 이동
- AWS Console -> EC2 검색 후 이동
- 인스턴스 클릭
- 인스턴스 시작 버튼 클릭
AMI(운영체제 이미지) 선택
- Ubuntu Server 22.04 LTS 선택 (여기서 SQL Server 말고, SSD Volume Type 선택)
- 인스턴스 타입 선택 (g4dn.xlarge) : 시간당 약 $0.5
키페어 생성
- 새 키페어 생성 클릭
- 이름 입력
- .pem 파일 형식 선택
- 다운로드 한 키 파일 보관 필수
보안이 필요하다면 방화벽 설정
- 사용자가 인터넷을 통해 AWS에 접근하는 공인 ip를 설정해야함

3. 인스턴스 시작 실패 Case - 계정 검증

인스턴스 시작 실패 Your request for accessing resources in this region is being validated, and you will not be able to launch additional resources in this region until the validation is complete. We will notify you by email once your request has been validated. While normally resolved within minutes, please allow up to 4 hours for this process to complete. If the issue still persists, then open a support case. [https://support.console.aws.amazon.com/support/home?region=us-east-1#/case/create?issueType=customer-service&serviceCode=account-management&categoryCode=account-verification]

<해결 방법>
Support Case 등록하기!
작성 예시
제목(Subject): EC2 인스턴스 시작이 불가능합니다
카테고리: Account verification 설명(Description)
내용 : Hello, I'm trying to launch a GPU EC2 instance for AI model training, but I received a message that my account is under validation and cannot access resources in the region. Please help to expedite the validation process as I'm testing my project in a time-sensitive environment. Thank you!

위와 같이 올리면 수분내로 처리해준다!

4. 인스턴스 시작 실패 Case - vCPU 한도 문제

You have requested more vCPU capacity than your current vCPU limit of 0 allows for the instance bucket that the specified instance type belongs to. Please visit http://aws.amazon.com/contact-us/ec2-request to request an adjustment to this limit.

<해결 방법>
Support Case 등록하기!
작성 예시
안녕하세요,
요청하신 인스턴스 한도 증가 정보를 아래와 같이 전달드립니다.
------------------------------------
한도 증가 요청 1
Service: EC2 Instances
Primary Instance Type: g4dn.xlarge
Region: US East (N. Virginia) (us-east-1)
한도 이름: Running On-Demand G and VT instances
새 한도 값: 4
------------------------------------
AI 모델 학습 및 테스트를 위한 용도로 g4dn.xlarge 인스턴스를 사용하고자 합니다.
빠른 검토 부탁드립니다. 감사합니다.

vCPU 한도 문제는 한국 AWS 서비스센터에서 처리가 안되는지, 미국 현지 서비스 팀이 검증해야해서 시간이 걸린다는 연락이 왔다..! 처리 될때까지 영업일로 3-4일? 정도 걸린것 같다 ㅎㅎ

5. SSH로 접속해보기

위 단계를 모두 마쳤으면 인스턴스에 할당된 ip로 접속할 수 있다.

EC2 -> 실행중인 인스턴스 -> 인스턴스 ID 클릭 하면 퍼블릭 IPv4 주소를 볼 수 있는데, 해당 주소로 접속하고, 2번에서 저장한 키를 로드해주면 접속할 수 있다.

주의점은 호스트 id를 ubuntu로 해야한다는 점!

CUDA & Nvidia Driver & cudnn 의 정의

whatisworth — Thu, 27 Mar 2025 15:03:37 +0900

AI서비스를 만드는 개발자라면 반드시 사용하고 있을 저 용어들,, 항상 모호하게 알고 있었던것 같아서 이번 기회에 한번 정리해보았다!

Nvidia Driver

미국의 "엔비디아" 라는 회사는 AI에 대해서 잘 모르는 일반인도 주식.. 때문에 많이 들어보았을 것이다. 이 엔비디아에서 만든 그래픽 카드(GPU)를 사용하여 Deep Learning 모델의 복잡한 연산을 빠르게 연산할 수 있다는 것이 밝혀지면서, 엔비디아의 가파른 성장세가 두드러졌었다.

여튼, 엔비디아에서 만든 그래픽 카드를 제어할 수있는 소프트웨어가 바로 nividia driver이다.

GPU를 컴퓨터에서 올바르게 인식하고 제어할 수 있도록 한다.
GPU의 하드웨어 리소스를 최적화하고, 그래픽 작업을 처리하기 위해 GPU에 명령을 전달하는 역할을 한다.
CUDA를 지원한다. (CUDA에 대한 설명은 후술함)

CUDA

Computed Unified Device Architecture 의 약자로, C/C++ 프로그래밍 언어를 기반으로 한다.

GPU에서 병렬 코드를 작성하고 실행할 수 있는 도구를 제공한다.

CUDA 는 GPU 컴퓨팅에서 일종의 컴파일러(인간의 언어에 가까운 고급언어로 작성된 프로그램을 기계어로 된 목적 프로그램으로 변환하는 역할) 역할을 한다.
CUDA를 사용하기 위해서는 Nvidia에서 제공하는 CUDA Toolkit을 설치해야한다.

cuDNN

cuda deep neural network library 의 약자로, 딥러닝 및 인공신경망 프레임 워크를 가속화 하기 위한 라이브러리이다.

pytorch, tensorflow 등, 기타 프레임워크와 통합되어 사용자가 프레임워크에서 cuDNN을 사용하여 모델을 개발하고 실행할 수 있도록 한다.

Web Socket vs API

whatisworth — Thu, 27 Mar 2025 14:49:16 +0900

이것저것 보다가 갑자기 궁금해졌다... 웹 소켓이나 api나 클라이언트-서버 사이의 연결을 도와주는 매개체인것 같은데,, 굳이 왜 따로 구분해놨을까? 어떤 차이가 있을까??

해서 정리해보았다.. ㅎㅎ..

공통점

웹소켓과 Rest API 모두 클라이언트와 서버 간의 통신을 하는데 사용되는 기술이다.

차이점

웹소켓 : 양방향 통신을 가능하게 하는 프로토콜이며, 클라이언트와 서버 간에 실시간으로 데이터를 주고받을 수 있다.

API : HTTP 프로토콜을 기반으로 하는 상태가 없는 통신 방식이다.

통신 방식의 특징

	웹소켓	API
데이터 교환 방식	실시간 통신을 위해 설계됨	HTTP 메소드(GET, POST, PUT, DELETE)등을 사용하여 리소스에 대한 CRUD를 수행
연결 방식	TCP 방식(한번의 연결이 이루어진 후에는 지속적인 데이터 교환이 가능함)	상태를 유지하지 않는 통신(주로 데이터 요청과 응답으로 이루어짐)
사용 예시	채팅, 게임, 실시간 피드 등 실시간으로 상호작용이 필요한 APP에 유용함	접속을 유지하고 있지 않아도 되는 블로그 시스템, SNS, 온라인 쇼핑몰 등
장점	반응 속도가 빠름	보안에 유리
단점	하이재킹 가능성	속도 느림

통신 예시

API
- 클라이언트: "현재 온도를 알려줘" 요청.
- 서버: 현재 온도 응답(한 번의 요청-응답으로 종료).
- 클라이언트가 새로운 데이터를 얻으려면 다시 요청을 보내야 함.
WebSocket
- 연결이 한번 설정되면, 클라이언트는 서버에 계속 데이터를 요청할 필요 없음
- 서버는 온도가 변할 때마다 클라이언트로 데이터를 푸시함.

AI 서비스 개발 분야에서는 어떻게 활용될까?

직접 경험해보았을 때, 웹소켓은 "실시간성" 이 중요한 서비스에서 주로 활용됐었다. 예를 들어서, cctv 영상을 실시간으로 받아서 이상행동을 탐지한다던지, 공정과정에서 데이터를 실시간으로 받아서 추론을 한다던지, 하는 것이였다.

API는 AI플랫폼 구축 처럼, 보안이 필요한 AI서비스 분야에서 주로 사용됐었다. 보안이 필수적이라 로그를 반드시 추적해야하는 분야에 주로 적용이 됐었던것 같다. 웹소켓은 연결이 계속 유지가 되기 때문에 하이재킹 등 문제가 발생할 여지가 있었다.

[논문 리뷰] U-Net 꼼꼼한 리뷰

whatisworth — Sat, 22 Mar 2025 18:47:55 +0900

Abstract

Deep Neural Network의 성공적인 학습을 위해서는 많은 양의 annotated training sample들이 필요하다.

이 paper에서는 annotated sample들을 더욱더 효율적으로 활용하기 위하여 Data augmentation기반의 새로운 network 와 training strategy 에 대하여 소개한다.

해당 구조는 context(이미지의 내용)를 capture하기 위하여 수축하는 path와 정확한 localization을 위한 symmetric한 확장 path로 구성되어 있다.

이러한 network는 적은 양의 image들에 대하여 end-to-end로 학습이 가능하다.

Introduction

Convolutional Network는 보통 classification task, 즉, image의 output 결과가 single class label인 경우였다.

그러나, 많은 visual task에서 특히 biomedical image processing 에서 기대하는 output은 localization 즉, class label이 pixel로 표시되어야 했다.

이 paper에서는 “fully convolutional network”라는 이름의 elegant한(ㅋㅋ,,) 구조로부터 구상되었다. 우리는 이 구조를 수정하고 확장하여 적은 양의 이미지들에 대해서도 작동할 수 있도록 하였으며, 보다 더 정확한 segmentation을 예측할 수 있도록 하였다.

fully convolutional network 란, 기존의 classification network에서 출력층의 fc layer를 conv layer, 즉 upsampling layer로 대체한 것이다.

즉, fully convolutional network의 주요 아이디어는 네트워크를 점점 축소하여 class label만을 예측할 수 있었던 기존의 CNN 네트워크와 달리, 마지막 출력층에 upsampling layer (즉, pooling 연산자 대신 upsampling 연산자를 추가함)을 추가하여 객체의 위치정보를 픽셀 단위로 표시할 수 있도록 한것이다.

따라서, 이러한 layer는 output의 해상도가 증가하게 해준다.

localize를 위해서는 contracting path로부터 나온 고해상도의 feature들이 upsample된 output과 결합된다.

기존의 FCN 구조와 비교해서 u-net 구조의 수정된 부분은 upsampling 하는 부분에서 feature channel의 개수를 늘림으로써 context information을 higher resolution layer에 전파할 수 있도록 한것이다.

결과적으로, expansive path (확장하는 경로)는 contracting path(수축 경로)와 symmetric하게 구성되며, 이는 u-shaped 구조로 나타난다.

해당 네트워크는 fully connected layers(모든 뉴런이 연결되어있는 상태) 즉 2차원에서 1차원으로 평탄화를 수행하는 layer가 없다.

이 이유는, segmentation task의 output 인 segmentation map이 input image의 conext 정보와 위치 정보를 담은 pixel만을 포함하기 때문에 fc layer가 필요 없기 떄문이다.

Network Architecture

해당 구조는 왼쪽 (contracting path) 와 오른쪽(expansive path) 로 이루어져있다.

contracting path는 convolutional network의 전형적인 구조를 따라간다.

contracting path 구성

3x3 convolutions + ReLU 2번
2x2 maxpooling layer 1번

를 4번 반복

각 downsampling path에서 feature channel의 개수를 두배씩 늘린다. (그림에서 보면, 64 channel의 개수를 downsampling을 통해 128개의 feature channel로 늘린것을 볼 수 있다. )

그 밑에 쓰여져있는 숫자, 572x572, 570x570 등등은 feature map의 height, width를 의미하는데, unet구조는 valid padding, 즉 padding을 사용하지 않았기 떄문에 convolution을 거칠때마다 output의 크기가 줄어드는 것을 볼 수 있다.

단계	연산	크기변화
입력		572 x 572
conv1	3×3 valid conv	570 x 570
conv2	3×3 valid conv	568 x 568
maxpool	2x2 maxpool	284 x 284
conv3	3x3 valid	282 x 282
conv4	3x3 valid	280 x 280
…	…	…

여기서 잠시, feature channel의 개수가 무엇을 의미하는지 알아보자.

feature channel의 개수란, 다음 그림에서 처럼 convolution 연산에서 필터의 depth를 의미한다.

https://devkor.tistory.com/entry/합성곱-신경망

expansive path 구성

contracting path에서 나온 feature map을 concatenation 시킴
2x2 up convolution 1번
3x3 convolutions + ReLU 2번

final layer 의 1x1 convolution은 semantic segmentation task 에 맞추어 공간 해상도를 유지하면서 채널의 수를 줄이기 위한 방법이다.

결과적으로 전체 네트워크는 23개의 convolutional layer를 가진다.

Skip Connection

Unet 구조에서 또 하나 중요한 점은, skip connection이라는 구조이다. 이 구조 덕에 unet 모델은 세밀한 구조까지 모두 살릴 수 있는 모델이 되었다고 할 수 있다!

skip connection은

Encoder(Contracting Path)에서 추출한 특징(feature map)을
Decoder(Expanding Path)에서 다시 활용하기 위해,
같은 레벨끼리 feature map을 직접 연결(concatenate) 해주는 구조라고 할 수 있다.

Downsampling(Pooling)을 하면 해상도가 작아지면서 공간 정보(특히 경계 정보)가 손실된다.
Decoder는 업샘플링으로 해상도를 복원하려고 하지만, 정확한 경계나 위치 정보는 이미 손실
따라서 Encoder의 고해상도 feature map을 Decoder에 건너뛰어(skip) 전달한다.

즉, 저해상도의 의미 정보와 고해상도의 위치 정보를 모두 활용하고자 하는 모델이라고 볼 수 있겠다.

Training

데이터 증강 : 해당 논문에서는 의료이미지를 훈련 데이터셋으로 사용하였기 때문에 데이터 수가 매우 부족하기 때문에 augmentation 기법이 필수적이다.

Augmentation

이 논문에서는 여러가지 augmentation 기법들 중 특히 elastic deformation을 사용하였다.

elastic deformation(탄성 변형) 이란?

이미지를 마치 고무처럼 비틀거나 흔드는 듯한 변형. 조직의 위치가 조금씩 다르더라도 모델이 잘 인식하도록 도와줌.

실제로는 gaussian filter를 사용하여 블러처리한다.

Loss Function

cross entropy 사용

$$ E = \Sigma_{x\in\Omega}w(x)log(p_{l(x)}(x)) $$

기호	의미
$$ Ω $$	이미지 상의 모든 픽셀 위치들의 집합 (즉, 전체 이미지 영역)
$$ x $$	개별 픽셀 위치
$$ l(x) $$	픽셀 x의 정답 클래스(label)
$$ p_{l(x)}(x) $$	픽셀 x에서 정답 클래스에 해당하는 확률값 (모델 출력 softmax 값)
$$ w(x) $$	픽셀 x에 부여된 가중치(weight) – 경계 강조 + 클래스 불균형 보정용

segmentation task는 절대적인 pixel 의 양으로 보았을 때, background는 매우 많고, target은 아주 적기 떄문에 weight에 가중치를 주었다.

$$ w(x) = w_c(x) + w_0 * exp( - \frac{(d1(x) + d2(x))^2}{2σ^2}) $$

두번째 항은 object 사이의 경계에 가까운 픽셀에 큰 값을 주고 있다. 즉, 가중치 기반 loss는 "배경은 너무 많으니까 덜 중요하게, 중요한 부분(장기, 경계 등)은 더 집중해서 배우자!"는 전략이다.

[코테]99클럽 코테 스터디 37일차 TIL 백준 11053 가장 긴 증가하는 부분수열

whatisworth — Tue, 18 Feb 2025 21:58:36 +0900

꽤나 유명한 DP문제이다. 사실 DP문제는 굉장히 자신이 없어서 한 5분 정도 고민하고 바로 답을 봤다..

dp[i]를 정의하는 것부터 꽤나 접근이 어려웠다.

dp[i]를 i번째 원소를 가장 마지막으로 하는 증가하는 부분수열의 최대 길이라고 한다.

그리고 모든 원소는 자기 자신을 부분수열로 가질 수 있으므로, dp 초기 테이블을 dp = [1] * N으로 잡을 수 있다.

예제를 표로 그려보면, 다음과 같다.

인덱스 i	A[i]	dp[i] 초기값
0	10	1
1	20	1
2	10	1
3	30	1
4	20	1
5	50	1

이전 dp 테이블 값 + 1 과 자기 자신의 dp 테이블 값을 비교했을 때 큰 값을 현재 자신의 dp 테이블 값으로 설정하는 점화식을 세우면 끝난다.

i = 1, A[1] = 20

j = 0: A[0] = 10 < A[1] → dp[1] = max(1, dp[0] + 1) = 2
dp = [1, 2, 1, 1, 1, 1]

i = 2, A[2] = 10

j = 0, j = 1: A[j] > A[2] → 패스
dp = [1, 2, 1, 1, 1, 1] (변화 없음)

i = 3, A[3] = 30

j = 0: A[0] = 10 < A[3] → dp[3] = max(1, dp[0] + 1) = 2
j = 1: A[1] = 20 < A[3] → dp[3] = max(2, dp[1] + 1) = 3
j = 2: A[2] = 10 < A[3] → dp[3] = max(3, dp[2] + 1) = 3
dp = [1, 2, 1, 3, 1, 1]

i = 4, A[4] = 20

j = 0: A[0] = 10 < A[4] → dp[4] = max(1, dp[0] + 1) = 2
j = 1, j = 2, j = 3: A[j] > A[4] → 패스
dp = [1, 2, 1, 3, 2, 1]

i = 5, A[5] = 50

j = 0: A[0] = 10 < A[5] → dp[5] = max(1, dp[0] + 1) = 2
j = 1: A[1] = 20 < A[5] → dp[5] = max(2, dp[1] + 1) = 3
j = 3: A[3] = 30 < A[5] → dp[5] = max(3, dp[3] + 1) = 4
dp = [1, 2, 1, 3, 2, 4]

import sys

read = sys.stdin.readline

N = int(read())

numbers = list(map(int, read().split()))

# dp[i] = i번째 원소를 마지막 원소로 하는 가장 긴 부분수열의 길이

# dp 테이블 초기화

dp = [1] * N

for i in range(1,N):

for j in range(i):

if numbers[j] < numbers[i]:

dp[i] = max(dp[i], dp[j] + 1)

print(max(dp))

[코테]99클럽 코테 스터디 36일차 TIL 백준 1003 피보나치 함수

whatisworth — Mon, 17 Feb 2025 22:01:51 +0900

일주일 동안 정신없이 면접보고.. 준비하고.. 하느라 한동안 코딩테스트를 못풀었다 ㅠ

좋은 결과가 나왔으면 좋겠는데.. 잘모르겠다 ㅠㅠ

어쨌든, 이 문제는 대표적인 DP문제이다. DP문제란, 분할정복과 비슷한 개념인데, 작은 것을 더해서 큰 것을 구한다? 느낌이다. 점화식이라고 보면 될것 같다.

나는 DP문제를 한번도 풀어본적이 없어서 처음에는 문제 그대로 피보나치 함수를 짜서 카운트만 해봤는데 시간초과로 실패했다. 다음은 실패한 코드.

import sys

read = sys.stdin.readline

T = int(read())

def fibonacci(n):

global zero_cnt, one_cnt

if n == 0:

zero_cnt += 1

return 0

elif n == 1:

one_cnt += 1

return 1

else:

return fibonacci(n - 1) + fibonacci(n - 2)

for _ in range(T):

N = int(read())

zero_cnt = 0

one_cnt = 0

fibonacci(N)

print(zero_cnt, one_cnt)

피보나치 함수 값만 더해서 나오는게 아니라, 1과 0의 호출 횟수도 점화식으로 나올 수 있다는 것이 이 문제의 포인트이다.

import sys

read = sys.stdin.readline

T = int(read())

# N의 최대 입력값이 40 이므로 미리 설정

dp = [(0,0)] * 41

dp[0] = (1,0)

dp[1] = (0,1)

for i in range(2, 41):

dp0 = dp[i - 1][0] + dp[i - 2][0]

dp1 = dp[i - 1][1] + dp[i - 2][1]

dp[i] = (dp0, dp1)

for _ in range(T):

N = int(read())

print(dp[N][0], dp[N][1])

[코테]99클럽 코테 스터디 24일차 TIL 백준 2529 부등호

whatisworth — Thu, 6 Feb 2025 00:00:34 +0900

https://www.acmicpc.net/problem/2529

일단 이 문제는 처음 보자마자 bruteforce 일것 같다라는 생각이 들었었다. 그런데 조금 더 생각해 보니 모두 다 탐색할 필요 없이 중간에 부등호에 맞지 않는 숫자배열이 나온다면 멈추는 알고리즘, 즉 백트래킹을 사용해야할 것 같다는 생각이 들었다..!

먼저 문자 부등호를 입력받아서 값을 비교하는 로직을 하나 짜고, 백트래킹 알고리즘을 활용하였다..!

최댓값, 최솟값만 구하면 되기 때문에 부등호에 맞는 가장 처음과 가장 마지막 숫자 배열을 프린트 해주기 위하여 함수를 두개 짰다.

주의할 점은, visited 와 global 변수 found를 max값 구하는 함수와 min값 구하는 함수에 각각 초깃값을 다르게 해주어야한다는 점이다.

import sys

read = sys.stdin.readline

k = int(read().rstrip())

inequality = list(map(str, read().split()))

# 문자 부등호를 이용해서 값 비교하기

def str2real(inequal, nums):

for i in range(k):

if inequal[i] == '<' and nums[i] >= nums[i+1]:

return False

if inequal[i] == '>' and nums[i] <= nums[i+1]:

return False

return True

visited = [False] * 10

ex_nums = [i for i in range(10)]

answer_min = []

answer_max = []

found_min = False

found_max = False

def find_min(depth):

global found_min

if found_min:

return

if depth == k + 1:

if str2real(inequality, answer_min):

print(''.join(map(str, answer_min)))

found_min = True

return

for i in range(10):

if not visited[i]:

visited[i] = True

answer_min.append(i)

find_min(depth+1)

visited[i] = False

answer_min.pop()

def find_max(depth):

global found_max

if found_max:

return

if depth == k + 1:

if str2real(inequality, answer_max):

print(''.join(map(str, answer_max)))

found_max = True

return

for i in range(10):

if not visited[i]:

visited[i] = True

answer_max.append(ex_nums[9-i])

find_max(depth+1)

visited[i] = False

answer_max.pop()

find_max(0)

visited = [False] * 10

find_min(0)

[코테]99클럽 코테 스터디 22일차 TIL 백준 1018 체스판 다시 칠하기

whatisworth — Mon, 3 Feb 2025 20:59:22 +0900

테스트 크기를 보고 딱 브루트포스알고리즘이겠다~ 해서 전부 다 탐색하는걸로 풀었는데 좀 오래걸렸다... 더 예쁘고 효율적인 풀이도 공부해야겠다

풀이 순서는

8*8 윈도우 모두 구하기
정답 체스판 2가지 구현해놓기
3중 for문으로 모든 윈도우에 대하여 정답과 다른 문자 카운트하기
최솟값 구하기

인데, 조금 더 예쁜 풀이도 찾아보았다..

내풀이

import sys

read = sys.stdin.readline

N, M = map(int,read().split())

chess_map = []

for _ in range(N):

chess_map.append(read().rstrip())

windows = []

for i in range(N-7):

window_xs = chess_map[i:i+8]

for j in range(M-7):

window = [w[j:j+8] for w in window_xs]

windows.append(window)

answer1 = []

for i in range(8):

if i % 2 == 0:

answer1.append('WBWBWBWB')

else:

answer1.append('BWBWBWBW')

answer2 = []

for i in range(8):

if i % 2 == 0:

answer2.append('BWBWBWBW')

else:

answer2.append('WBWBWBWB')

result = sys.maxsize

for window in windows:

cnt_1 = 0

cnt_2 = 0

for i in range(8):

for j in range(8):

if window[i][j] != answer1[i][j]:

cnt_1 += 1

if window[i][j] != answer2[i][j]:

cnt_2 += 1

result = min(cnt_1,cnt_2,result)

print(result)

예쁜 풀이

import sys

def min_paint(chessboard, x, y):

# 체스판 패턴 2가지 생성

pattern1 = [ "BWBWBWBW", "WBWBWBWB" ] * 4

pattern2 = [ "WBWBWBWB", "BWBWBWBW" ] * 4

count1, count2 = 0, 0

for i in range(8):

for j in range(8):

if chessboard[x + i][y + j] != pattern1[i][j]:

count1 += 1

if chessboard[x + i][y + j] != pattern2[i][j]:

count2 += 1

return min(count1, count2)

def solution():

n, m = map(int, sys.stdin.readline().split())

board = [sys.stdin.readline().strip() for _ in range(n)]

min_changes = float('inf')

for i in range(n - 7):

for j in range(m - 7):

min_changes = min(min_changes, min_paint(board, i, j))

print(min_changes)

[코테]백준 17144 미세먼지 안녕! 파이썬

whatisworth — Sun, 2 Feb 2025 16:33:53 +0900

https://www.acmicpc.net/problem/17144

이문제,, 너무 어려웠다 ㅠㅠ 정말 거의 반나절 걸려서 간신히 풀었는데,, ㅠㅠ 자괴감이... 난 언제 이런 문제 술술 잘 풀려나,,, 여튼 나의 패착은 두 가지였다.

미세먼지 확산을 bfs로 해결하려고 했던 것
간신히 정신줄 잡고 그냥 시뮬레이션으로 확산 돌렸는데 기존 graph값을 계속 변화시키는 방향으로 함수를 짜는 바람에 계속 답이 안나옴
공기청정기 방향 아이디어는 잘 잡았는데 테스트케이스 반복문으로 돌리는 과정에서 공기청정기 위치를 초기화 안해줘서...

느낀점은,, 진짜 시뮬레이션은 엄청엄청 꼼꼼해야하구나,,, ㅠㅠㅠ 후...

전체 코드는 다음과 같다.! 헷갈리는 부분은 주석을 달아두었다..

import sys

from collections import deque

from unittest import result

read = sys.stdin.readline

R, C, T = map(int,read().split())

graph = []

for _ in range(R):

graph.append(list(map(int, read().split())))

# 공기청정기 위치 구하고 초기화 하기

air_fresh = []

for i in range(R):

for j in range(C):

if graph[i][j] == -1:

air_fresh.append((i,j))

graph[i][j] = 0

air_fresh.sort()

dx = [-1,1,0,0]

dy = [0,0,-1,1]

# 미세먼지 확산

''' 키포인트 : graph[i][j] -= (graph[i][j] // 5) 해버리면

grpah의 값이 계속 변화하기 때문에 정상적인 업데이트가 불가능하다.

'''

def spread():

new_graph = [[0 for _ in range(C)] for _ in range(R)]

for i in range(R):

for j in range(C):

if graph[i][j] != 0:

spread_count = 0

for k in range(4):

ni = i + dx[k]

nj = j + dy[k]

if 0 <= ni < R and 0 <= nj < C and (ni,nj) != air_fresh[0] and (ni,nj) != air_fresh[1]:

new_graph[ni][nj] += (graph[i][j] // 5)

spread_count += 1

new_graph[i][j] += graph[i][j] - (graph[i][j] // 5) * spread_count

return new_graph

def air_fresher():

up_line = []

down_line = []

up_x, up_y = air_fresh[0]

down_x, down_y = air_fresh[1]

# 우 상 좌 하

while 0 <= up_y < C - 1:

up_y += 1

up_line.append((up_x,up_y))

while 0 < up_x < R:

up_x -= 1

up_line.append((up_x,up_y))

while 0 < up_y < C:

up_y -= 1

up_line.append((up_x,up_y))

while 0 <= up_x < air_fresh[0][0] - 1:

up_x += 1

up_line.append((up_x,up_y))

# 우 하 좌 상

while 0 <= down_y < C - 1:

down_y += 1

down_line.append((down_x,down_y))

while 0 <= down_x < R - 1:

down_x += 1

down_line.append((down_x,down_y))

while 0 < down_y < C:

down_y -= 1

down_line.append((down_x,down_y))

while down_x > air_fresh[1][0]:

down_x -= 1

down_line.append((down_x,down_y))

return up_line, down_line

for _ in range(T):

result_graph = [[0 for _ in range(C)] for _ in range(R)]

spread_graph = spread()

up_line, down_line = air_fresher()

for i in range(len(up_line)-1):

x,y = up_line[i][0], up_line[i][1]

nx,ny = up_line[i+1][0], up_line[i+1][1]

result_graph[nx][ny] = spread_graph[x][y]

for i in range(len(down_line)-1):

x,y = down_line[i][0], down_line[i][1]

nx,ny = down_line[i+1][0], down_line[i+1][1]

result_graph[nx][ny] = spread_graph[x][y]

result_graph[air_fresh[0][0]][air_fresh[0][1]] = 0

result_graph[air_fresh[1][0]][air_fresh[1][1]] = 0

for i in range(R):

for j in range(C):

if (i,j) not in up_line and (i,j) not in down_line:

result_graph[i][j] = spread_graph[i][j]

graph = result_graph

cnt = sum(sum(row) for row in graph)

print(cnt)

[코테]백준 9012 괄호 파이썬

whatisworth — Sun, 2 Feb 2025 01:09:04 +0900

https://www.acmicpc.net/problem/9012

스택 문제 중에 가장 유명한 괄호 문제이다! 내 기억에는 프로그래머스에서도 비슷한 문제를 봤던 것 같다...

스택이란 자료구조는 LIFO 구조로, Last In First Out 구조이다. 파이썬에서는 리스트라고 보면된다.

만약에 코테에 스택 문제가 나온다? 하면 거의 무조건 append, pop만 쓰면 된다..! 다른 내장 함수 쓰는거는 거의 본적이 없다.

여튼, 이 문제는 짝이 맞는지 확인해주는 빈 스택을 따로 정해주는 문제이다. 코테 식 문제풀이는 뭔가를 판단할 때 이런식으로 딕셔너리든, 리스트든 새로운 자료구조를 정의해서 판단용으로 사용하는 문제가 많은것 같다...

전체 코드는 다음과 같다.

import sys

def is_vps(string):

stack = []

for char in string:

if char == '(':

stack.append(char)

elif char == ')':

if not stack: # 스택이 비어있는데 ')'가 나오면 올바르지 않은 괄호열

return "NO"

stack.pop()

return "YES" if not stack else "NO" # 스택이 비어있으면 올바른 괄호열

read = sys.stdin.readline

T = int(read())

for _ in range(T):

print(is_vps(read().rstrip()))

[코테]백준 1913 달팽이 파이썬

whatisworth — Fri, 31 Jan 2025 20:11:05 +0900

https://www.acmicpc.net/problem/1913

이 문제는 나선형으로 숫자를 배열하는 문제인데, 하우상좌로 이동하는것은 파악했는데 이동방식을 어떻게 조건문을 줘야할 지 몰라서 헤맸던 문제다.. ㅠㅠ 특히 계속 중앙인 1에서부터 시작하려고 했어서 막혔던 문제이다... ㅠㅠ

전체 코드는 다음과 같다.

이동시 조건은 그냥 범위를 벗어나지 않는지, 0이 아닌지만 주면 되는.. 싱거운 문제였다 ㅠㅠ

import sys

read = sys.stdin.readline

N = int(read())

M = int(read())

arr = [[0 for _ in range(N)] for _ in range(N)]

# 하우상좌

dx = [1,0,-1,0]

dy = [0,1,0,-1]

dir = 0

num = N ** 2

x, y = 0, 0

while num > 0:

arr[x][y] = num

if num == M:

target_x, target_y = x + 1, y + 1

nx, ny = x + dx[dir], y + dy[dir]

if not (0 <= nx < N and 0 <= ny < N and arr[nx][ny] == 0):

dir = (dir+1) % 4

nx, ny = x + dx[dir], y + dy[dir]

x, y = nx, ny

num -= 1

for row in arr:

print(*row)

print(target_x, target_y)

[코테]백준 16236 아기상어 파이썬

whatisworth — Fri, 31 Jan 2025 14:48:29 +0900

https://www.acmicpc.net/problem/16236

이 문제는 기본 BFS에 여러가지 조건이 붙은 문제여서 구현하기가 좀 까다로웠다.

문제의 특징을 몇가지 말해보자면,

아기상어의 위치를 구하고 그 자리를 0으로 초기화 해주기
아기상어의 이동(BFS)와 물고기를 먹으면서 크기를 성장하는 로직을 따로 작성해주기
BFS에서 먹은 물고기의 위치, 거리를 리스트로 저장해서 정렬하기

가 있다. 특히 세번째의 경우 굉장히 중요한 포인트인데, 나는 처음에 BFS로 이동하면 자동으로 제일 위에 있는 물고기, 제일 왼쪽에 있는 물고기부터 먹을줄 알았다.

"거리가 가까운 물고기가 많다면, 가장 위에 있는 물고기, 그러한 물고기가 여러마리라면, 가장 왼쪽에 있는 물고기를 먹는다."

이 부분을 어떻게 구현하느냐를 생각하기가 참 애먹었었는데, 간단하게 정렬을 이용하면 되는 것이였다.

이 복잡한 문제의 전체 코드는 다음과 같다.

import sys

from collections import deque

read = sys.stdin.readline

N = int(read())

graph = []

for _ in range(N):

graph.append(list(map(int, read().split())))

for i in range(N):

for j in range(N):

if graph[i][j] == 9:

start_x = i

start_y = j

graph[i][j] = 0

dx = [-1,1,0,0]

dy = [0,0,-1,1]

def bfs(x,y,size):

queue = deque([(x,y,0)])

visited = [[False for _ in range(N)] for _ in range(N)]

visited[x][y] = True

fishes = []

while queue:

x,y,dist = queue.popleft()

for i in range(4):

nx = x + dx[i]

ny = y + dy[i]

if 0 <= nx < N and 0 <= ny < N and not visited[nx][ny]:

if size >= graph[nx][ny]:

visited[nx][ny] = True

queue.append((nx,ny,dist+1))

if 0 <= graph[nx][ny] < size:

# 만약 이쪽에서 방문처리를 해주게 되면 먹을 수 있는 물고기만 방문처리하게 되므로, 같은 크기의 물고기나 빈칸은 방문 x

fishes.append((dist+1,nx,ny))

if fishes:

fishes.sort()

return fishes[0]

return None

fish_size = 2

fish_cnt = 0

time = 0

while True:

result = bfs(start_x,start_y,fish_size)

if result is None:

break

dist, x, y = result

time += dist

fish_cnt += 1

if fish_size == fish_cnt:

fish_size += 1

graph[x][y] = 0

start_x = x

start_y = y

print(time)

[코테]99클럽 코테 스터디 10일차 TIL 백준 2573 빙산

whatisworth — Sun, 26 Jan 2025 16:37:33 +0900

https://www.acmicpc.net/problem/2573

이 문제는 그래프 탐색 문제로, 문제에서 설명하는대로 착실하게 구현만 하면 되는?(그게 어렵지만,,)문제라고 할 수 있다.

빙산이 분리가 되는지 탐색하는 것은 bfs를 통해 구현하였고, 1년 후 빙산의 상태는 이중 for문으로 구현하였다.

중요한 점은 방문 그래프가 반복문을 실행할 때마다 초기화 되어야 한다는 것이다.

import sys

from collections import deque

read = sys.stdin.readline

N, M = map(int, read().split())

graph = []

for _ in range(N):

graph.append(list(map(int, read().split())))

# 상하좌우

dx = [-1,1,0,0]

dy = [0,0,-1,1]

# 경계 검사 함수

def is_valid(x, y):

return 0 <= x < N and 0 <= y < M

# 다 녹았는지 검사

def is_melt(graph):

for i in range(N):

for j in range(M):

if graph[i][j] != 0:

return False

return True

# 1년 후 빙산 상태

def after_one_year(graph):

new_graph = [row[:] for row in graph] # 기존 그래프 복사

for i in range(N):

for j in range(M):

if graph[i][j] > 0: # 현재 위치가 0이 아닐 때만

cnt = sum(1 for k in range(4) if is_valid(i + dx[k], j + dy[k]) and graph[i + dx[k]][j + dy[k]] == 0)

new_graph[i][j] -= cnt

if new_graph[i][j] < 0:

new_graph[i][j] = 0

return new_graph

def bfs(x,y,visited,graph):

queue = deque([(x,y)])

visited[x][y] = True

while queue:

x, y = queue.popleft()

for i in range(4):

nx = x + dx[i]

ny = y + dy[i]

if 0 <= nx < N and 0 <= ny < M and graph[nx][ny] != 0 and not visited[nx][ny]:

visited[nx][ny] = True

queue.append((nx,ny))

def result(graph):

year_cnt = 0

while True:

# 녹기 전 빙산 덩어리 수 확인

visited = [[False for _ in range(M)] for _ in range(N)]

ice_cnt = 0

for i in range(N):

for j in range(M):

if graph[i][j] != 0 and not visited[i][j]:

ice_cnt += 1

bfs(i, j, visited, graph)

if ice_cnt >= 2: # 빙산이 분리된 경우

return year_cnt

if is_melt(graph): # 모든 빙산이 녹은 경우

return 0

# 1년 경과

graph = after_one_year(graph)

year_cnt += 1

print(result(graph))

[코테] 백준 14891 톱니바퀴 파이썬

whatisworth — Wed, 22 Jan 2025 23:36:03 +0900

https://www.acmicpc.net/problem/14891

빡구현으로 유명한 삼성 기출문제이다. 꼼꼼하지 못한 나는 언제 이런 문제를 빠르게 풀 수 있을까,, 한숨이 나왔지만 어쨌든 정진하기로...ㅠㅜㅠ

이 문제의 특징은 톱니바퀴의 회전을 양옆으로 전파 시켜야 한다는 것이다. 나는 처음에 각 톱니바퀴의 순서에 따라 회전하는 방향을 모두 지정하려고 했었는데, 굳이 그럴 필요가 없었다.

import sys

read = sys.stdin.readline

cogwheel_state = []

for _ in range(4):

cogwheel_state.append(list(map(int,read().rstrip())))

K = int(input())

turns = []

for _ in range(K):

turns.append(list(map(int,read().split())))

def clockwise(wheel):

new = [wheel[-1]]

for w in wheel[:-1]:

new.append(w)

return new

def counter_clockwise(wheel):

new = []

for w in wheel[1:]:

new.append(w)

new.append(wheel[0])

return new

for turn in turns:

# 맞닿는 톱니 위치

meets = [[None,cogwheel_state[0][2]],

[cogwheel_state[1][6],cogwheel_state[1][2]],

[cogwheel_state[2][6],cogwheel_state[2][2]],

[cogwheel_state[3][6],None]]

# 안움직이면 0, 시계방향 1, 반시계방향 -1 로 저장

move_or_not = [0] * 4

# 시작 톱니바퀴 회전 방향 저장

move_or_not[turn[0]-1] = turn[1]

# 왼쪽으로 전파

for i in range(turn[0] - 1, 0, -1):

if meets[i][0] != meets[i - 1][1]:

move_or_not[i - 1] = -move_or_not[i]

else:

break

# 오른쪽으로 전파

for i in range(turn[0] - 1, 3):

if meets[i][1] != meets[i + 1][0]:

move_or_not[i + 1] = -move_or_not[i]

else:

break

for idx,mv in enumerate(move_or_not):

if mv == 1:

cogwheel_state[idx] = clockwise(cogwheel_state[idx])

elif mv == -1:

cogwheel_state[idx] = counter_clockwise(cogwheel_state[idx])

score = 0

if cogwheel_state[0][0] == 1:

score += 1

if cogwheel_state[1][0] == 1:

score += 2

if cogwheel_state[2][0] == 1:

score += 4

if cogwheel_state[3][0] == 1:

score += 8

print(score)

[코테]99클럽 코테스터디 8일차 TIL 백준 2667 단지번호붙이기

whatisworth — Wed, 22 Jan 2025 22:36:53 +0900

https://www.acmicpc.net/problem/2667

이 문제는 DFS와 BFS모두 풀이가 가능한 문제이다.

나는 BFS로 풀었는데, 사실 BFS는 구현하기가 어렵진 않았지만, 잊어버린 부분이 몇가지 있다.

방문 리스트를 초기화할때,

visited = [[False] * N] * N

이런식으로 하게되면, visited 배열의 모든 행이 같은 리스트 객체를 참조하도록 만들기 때문에, 나중에 방문처리를 하게 될때, 한 행의 값을 수정하면, 모든 행의 값이 동시에 변경된다.

visited = [[False for _ in range(N)] for _ in range(N)]

이렇게 초기화 해야한다!

또 주의해야할 부분은 bfs(0,0)만 하게 되면 단지 하나만 탐색하고 끝나버리는데, 이를 방지하기 위하여 이중 for문으로 모든 좌표에 대하여 bfs를 수행했었다. 그런데 굳이 다 탐색할 필요는 없고, 방문을 안한 좌표 이면서 그래프 값이 1인 것에 대해서만 탐색하면 됐었는데, 그 포인트를 생각하지 못하는 바람에 틀려버렸다.

num_danji = 0

results = []

for i in range(N):

for j in range(N):

result = bfs(i,j)

if result != 0:

num_danji += 1

results.append(result)

print(num_danji)

이 코드가 아니라,

num_danji = 0

results = []

for i in range(N):

for j in range(N):

# graph[i][j] == 1 이고, 방문하지 않은 곳에서만 BFS 호출

if graph[i][j] == 1 and not visited[i][j]:

num_danji += 1

results.append(bfs(i, j))

print(num_danji) # 단지 수 출력

for result in sorted(results): # 각 단지 크기 오름차순 출력

print(result)

이렇게 해야한다!

전체 코드는 다음과 같다.

import sys

from collections import deque

read = sys.stdin.readline

N = int(read())

graph = []

for _ in range(N):

graph.append(list(map(int,list(read().rstrip()))))

dx = [-1,1,0,0]

dy = [0,0,-1,1]

visited = [[False for _ in range(N)] for _ in range(N)]

def bfs(x,y):

queue = deque([(x,y)])

visited[x][y] = True

cnt = 1

while queue:

x, y = queue.popleft()

for i in range(4):

nx = x + dx[i]

ny = y + dy[i]

if 0 <= nx < N and 0 <= ny < N and graph[nx][ny] == 1 and not visited[nx][ny]:

queue.append((nx,ny))

visited[nx][ny] = True

cnt += 1

return cnt

num_danji = 0

results = []

for i in range(N):

for j in range(N):

# graph[i][j] == 1 이고, 방문하지 않은 곳에서만 BFS 호출

if graph[i][j] == 1 and not visited[i][j]:

num_danji += 1

results.append(bfs(i, j))

print(num_danji) # 단지 수 출력

for result in sorted(results): # 각 단지 크기 오름차순 출력

print(result)

[코테]99클럽 코테스터디 7일차 TIL 백준 1697 숨바꼭질

whatisworth — Tue, 21 Jan 2025 22:04:59 +0900

https://www.acmicpc.net/problem/1697

이번 문제도 어제와 마찬가지로 그래프 탐색 문제이다. 나는 항상 코딩테스트 문제를 잘 풀기 위해서는 이 문제를 어떤 알고리즘을 사용하여 풀어야할지 고민해봐야한다고 생각하는데, 이문제는 최단경로 라는 단어에서 힌트를 준것 같았다. DFS는 깊이 우선탐색으로, 특정한 경로를 원할 때 주로 사용한다고 보면되고, BFS는

탐색을 현재 노드와 가까운 노드부터 순서대로 진행합니다.
큐를 사용하며, 먼저 들어온 노드부터 처리됩니다.
특징: BFS는 모든 경로를 동일한 깊이(거리)로 탐색하므로, 특정 노드에 처음 도달한 순간이 곧 최단 경로임이 보장됩니다.
라는 특징 때문에 이 문제에 사용할 수 있다고 생각하였다.

처음에는 node를 print하면 최단경로가 나올줄 알았는데, node는 단지 방문 여부만 체크하므로, -1, +1, *2의 계산 방식으로 나올 수 있는 노드가 가까운 순서로 전부 나올뿐이였다. (예제의 경우5,4,6,10,3,8,7 등등)

import sys

from collections import deque

read = sys.stdin.readline

N, K = map(int, read().split())

visited = [False] * (max(N,K) * 2 + 1)

def bfs(start):

queue = deque()

queue.append(start)

visited[start] = True

while queue:

node = queue.popleft()

print(node)

if node == K:

return

for i in [node-1, node+1, 2*node]:

if 0 <= i < max(N,K) * 2 + 1 and not visited[i]:

queue.append(i)

visited[i] = True

bfs(N)

따라서 GPT의 도움을 받아,,(나혼자 풀게될 날 언제오려나,,) 최단 거리를 체크하는 코드를 추가하여 다음과 같이 작성하여 성공하였다.

import sys

from collections import deque

# 입력

read = sys.stdin.readline

N, K = map(int, read().split())

# 방문 배열 생성

visited = [False] * (max(N,K) * 2 + 1)

def bfs(start, target):

# 큐에 현재 위치와 이동 횟수를 저장

queue = deque([(start, 0)]) # (현재 위치, 이동 횟수)

visited[start] = True

while queue:

node, distance = queue.popleft()

# 목표에 도달하면 이동 횟수 반환

if node == target:

return distance

# 가능한 다음 위치 탐색

for next_node in [node - 1, node + 1, node * 2]:

# 범위를 벗어나지 않고 방문하지 않은 경우만 큐에 추가

if 0 <= next_node < max(N,K) * 2 + 1 and not visited[next_node]:

queue.append((next_node, distance + 1))

visited[next_node] = True

# BFS 호출 및 결과 출력

result = bfs(N, K)

print(result)

[코테]99클럽 코테스터디 6일차 TIL 백준 1260 DFS와 BFS

whatisworth — Mon, 20 Jan 2025 23:01:06 +0900

https://www.acmicpc.net/problem/1260

99클럽 1주차는 이분탐색이나 투포인터 문제를 풀었다면, 2주차의 문제 주제는 그래프 탐색인 것 같다. 이번 문제는 DFS와 BFS의 개념을 확실히 알 수 있는 문제이다.

먼저 그래프는 두가지 형태로 입력받을 수 있는데, 인접행렬과 인접리스트 형태이다.

인접행렬과 인접리스트의 차이는 다음과 같다.

예를 들어 다음과 같은 그래프가 있다고 가정해볼 때, 인접행렬과 인접리스트는 다음과 같이 입력될 수 있다.

1. 인접행렬 : 각 노드가 연결되어 있는지 아닌지를 0혹은 1로 나타낸 행렬이다. (모든 노드에 대한 연결정보를 저장하므로, 공간메모리가 소모되서 잘 안쓰이는 것 같다.)

2. 인접리스트 : 각 연결 정보를 중첩리스트를 활용하여 나타낸 것이다. 보통 정점의 개수 + 1 만큼 빈 리스트를 주는데, 그 이유는 리스트의 각 인덱스가 정점의 번호 역할을 하기 때문에 0번 역할을 하는 리스트는 비워놓기 때문이다.

graph = [[],[2,3,4],[1,4],[1,4],[1,2,3]]으로 작성해볼 수 있다.

이제 이문제의 핵심인 DFS와 BFS의 차이점은 한 마디로 노드의 탐색을 깊이를 우선으로 하는지, 너비를 우선으로 하는지이다.

DFS는 깊이 우선탐색으로, 시작 노드로부터 출발해서 연결되어지는 노드 끝까지 계속해서 탐색한다. 이 특징을 재귀함수로 다음과 같이 표현할 수 있다.

def dfs(start):

visited[start] = True

print(start, end=" ")

for node in graph[start]:

if not visited[node]:

dfs(node)

BFS는 너비 우선탐색으로, 시작노드부터 출발해서 양옆의 노드부터 층층이 탐색하는 방식이다. 큐를 이용해서 표현할 수 있다.

def bfs(start):

queue = deque()

queue.append(start)

visited[start] = True

while queue:

node = queue.popleft()

print(node, end=" ")

for i in graph[node]:

if not visited[i]:

visited[i] = True

queue.append(i)

dfs와 bfs 구현도 중요하지만, 또 한가지 중요한 점은 방문할 수 있는 정점이 여러 개인 경우에는 정점 번호가 작은 것을 먼저 방문하게 하기 위하여 입력한 인접리스트를 오름차순으로 정렬해준 다음 dfs와 bfs에 넣어주어야 한다는 것이다.

전체 코드는 다음과 같다.

import sys

from collections import deque

read = sys.stdin.readline

N, M, V = map(int, read().split())

graph = [[] for _ in range(N+1)]

for _ in range(M):

inputs = list(map(int, read().split()))

graph[inputs[0]].append(inputs[1])

graph[inputs[1]].append(inputs[0])

for i in graph:

i.sort()

def dfs(start):

visited[start] = True

print(start, end=" ")

for node in graph[start]:

if not visited[node]:

dfs(node)

def bfs(start):

queue = deque()

queue.append(start)

visited[start] = True

while queue:

node = queue.popleft()

print(node, end=" ")

for i in graph[node]:

if not visited[i]:

visited[i] = True

queue.append(i)

visited = [False] * (N+1)

dfs(V)

print()

visited = [False] * (N+1)

bfs(V)

[코테]99클럽 코테 스터디 5일차 TIL 백준 2470 두 용액

whatisworth — Sat, 18 Jan 2025 09:56:20 +0900

https://www.acmicpc.net/problem/2470

이 문제는 투포인터 문제이다! 이분탐색과 상당히 비슷해보이지만, 다른 점이 있는데, 이분탐색이 중간점(mid)를 타겟 값과 계속해서 비교해 나가면서 범위를 좁혀나가는 방식이라면, 투포인터 문제는 말 그대로 움직이는 포인터(start, end)가 두개이다! 즉, 양 끝단에서 두 포인터를 움직여가면서 조건에 만족하는 답을 찾아내는 방식이라고 할 수 있다.

이 문제는 정렬된 용액의 특성값 리스트에서 두 포인터가 만날 때까지 현재 용액의 특성값의 합과 이전 용액의 특성값의 합의 크기를 비교해 나가면서 현재 용액의 특성값의 부호가 달라지는 조건에 따라 포인터를 움직이는 방식으로 풀었다.

import sys

read = sys.stdin.readline

N = int(read())

drinks = list(map(int, read().split()))

drinks.sort()

start, end = 0, N - 1

target_sum = sys.maxsize

best_pair = (0,0)

while start < end:

current_sum = drinks[start] + drinks[end]

if abs(current_sum) < target_sum:

target_sum = abs(current_sum)

best_pair = (drinks[start], drinks[end])

if current_sum < 0:

start += 1

else:

end -= 1

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

[코테]99클럽 코테 스터디 3일차 TIL 백준 11663 선분 위의 점

whatisworth — Wed, 15 Jan 2025 23:11:47 +0900

https://www.acmicpc.net/problem/11663

해당 문제는 앞선 두 문제와 마찬가지로 이분탐색 문제이다! 문제를 보자마자 이분탐색인 것을 깨달았던 것이, 어떤 값이 어떤 리스트에서 어떤 위치를 차지하는지? 에 대한 문제였기 때문에 바로 알아차릴 수 있었다.

처음 풀이는 공간 메모리 초과 오류가 떴는데, 그 이유는 주어진 선분의 처음과 끝을 for문으로 길게 늘린다음 해당 점이 그 안에 포함되어 있는지 이분탐색으로 찾았기 때문이였다.

import sys

read = sys.stdin.readline

N, M = map(int, read().split())

coord = list(map(int, read().split()))

lines = []

for _ in range(M):

lines.append(list(map(int, read().split())))

def bisection(target, data):

start = 0

end = len(data) - 1

while start <= end:

mid = (start + end) // 2

if target == data[mid]:

return mid

elif target > data[mid]:

start = mid + 1

else:

end = mid - 1

return

for line in lines:

data = [i for i in range(line[0],line[-1] + 1)]

cnt = 0

for coor in coord:

if bisection(coor, data) is not None:

cnt += 1

print(cnt)

이 문제로 인해 bisect 모듈을 사용하면서, 선분의 처음과 끝을 각각 target 값으로 잡고 정렬된 점의 좌표 안에 선분의 처음과 끝 값이 포함되는지 확인하는 방식으로 바꾸었더니 통과하였다.

import sys

from bisect import bisect_left, bisect_right

read = sys.stdin.readline

N, M = map(int, read().split())

coord = list(map(int, read().split()))

lines = []

for _ in range(M):

lines.append(list(map(int, read().split())))

coord.sort()

for line in lines:

start, end = line[0], line[1]

left_idx = bisect_left(coord, start)

right_idx = bisect_right(coord, end)

print(right_idx - left_idx)

[코테]99클럽 코테 스터디 2일차 TIL 백준 1654 랜선자르기

whatisworth — Tue, 14 Jan 2025 21:58:19 +0900

https://www.acmicpc.net/problem/1654

백준에서 이분탐색의 두번째 문제로 랜선자르기 문제를 풀어보았다.

이전에 암기왕에서 이분탐색 알고리즘을 그대로 사용했다면, 이번 문제는 실버2 단계의 문제인 만큼 조금의 응용이 필요했다. 기본 이분탐색 알고리즘이 정렬된 리스트에서 찾고자 하는 숫자의 인덱스 정보를 이분법으로 나누어 찾았다면, 이번 문제는 start, end의 값을 랜선의 길이로 바꾸어주어야 했다...!

import sys

read = sys.stdin.readline

K, N = map(int, read().split())

lans = []

for _ in range(K):

lans.append(int(read()))

def binary_search(data):

start = 1

end = max(data)

while start <= end:

mid = (start + end) // 2

target = 0

for d in data:

target += (d // mid)

if N > target:

end = mid - 1

else:

start = mid + 1

return end

print(binary_search(lans))

[코테]99클럽 코테 스터디 1일차 TIL 백준 2776 암기왕

whatisworth — Mon, 13 Jan 2025 22:36:39 +0900

1월 13일 자로 코테 스터디를 시작하게 되었다! 앞으로 TIL(Today I Learned)챌린지로 매일 문제를 풀고 업로드할 예정이다...!

https://www.acmicpc.net/problem/2776

1차 시도 : 간단하게 for문으로 수첩2의 모든 숫자들과 수첩1의 모든 숫자들을 비교해서 있으면 1을 출력하고 없으면 0을 출력하는 방식 -> 시간 초과 실패

2차 시도 : 입력의 최대값이 100만인 것을 보고 일반적인 탐색으로는 안되겠다 싶어 이분탐색을 정의해서 적용해보았지만 시간초과 실패 ㅠㅠ

3차 시도 : binary search 함수 안에 sorting하는 함수가 반복적으로 들어가기 떄문에 시간초과나는 것을 발견하고 수정하여 최종 성공하였다...! (feat.GPT 선생 참으로 똑똑하오...!)