justkeepintouch 님의 블로그

나 자신으로 살아가기

justkeepintouch — Fri, 19 Jun 2026 10:24:37 +0900

Stop Scrolling

Stop Hating and Start Loving

책 :
- 트랜서핑 (불안한 생각 대신 긍정적인 생각을 선택해야하는 물리, 우주적 관점)
넷플릭스 :
- 소셜딜레마 (소셜 미디어가 사람에게 미치는 영향, 인공지능에 지배된 삶)
유튜브 :
- 도파민 중독에서 벗어나는 법 https://www.youtube.com/watch?v=rc8YFSr8Ayk
- 불안함을 없애는 마인드 + 시간은 공평하지 않다 https://youtu.be/bqSL86SrAcU?si=cGMd1sWsvMXxWVZr

네이버 영화 리뷰 감성 분류하기(TF-IDF, TF), 텍스트 토크나이징, 벡터화

justkeepintouch — Thu, 18 Jun 2026 11:12:08 +0900

두두둥!
이번 시간에는 "네이버 영화 리뷰"를 가지고 긍정/부정 분류하는 딥러닝 모델을 만들어 보자!!

개인적으론 이번 실습 실제 영화 리뷰 데이터를 활용하여 하는 작업이다 보니까 젤 재밌었다

우선 데이터는 크게 2가지로 나뉜다

정형 데이터(숫자)
비정형 데이터(이미지, 문자, 음성)

숫자 데이터의 경우 바로 MLP 모델 input에 넣을 수 있지만, 비정형 데이터의 경우 컴퓨터가 해당 데이터를 읽을 수 없기 때문에 컴퓨터가 읽을 수 있는 숫자로 바꿔주는 벡터화 작업이 필요하다

이미지 데이터 전처리

이미지 데이터의 경우 이미 픽셀이라는 숫자로 이루어져 벡터화 작업 없이
MLP input에 넣기 위한 1D Flatten 작업만을 진행하면 되지만,

텍스트 데이터 전처리

text 데이터는 문자열 -> 토크나이징(쪼개기) -> 벡터(숫자로 변경) -> 벡터 단어사전 만들기 하는 작업이 필요하다

토큰화를 어떻게 하는 것이 좋을까?

한국어는 어근 뒤에 어미, 조사가 붙어 하나의 단어처럼 쓰이는 교착어 형태이다

ex) 성호가 자연어 처리 수업을 한다 -> 자립(성호, 자연어, 처리, 수업) + 의존(-가, -을, 하-, -ㄴ다)

이렇게 크게 자립 형태소와, 의존 형태소로 나눠줄 수 있다

만약 이걸 형태소 단위가 아닌, word 단위로 자른다고 생각해보자

ex) 성호가 자연어 처리 수업을 한다 -> 성호가, 자연어, 처리, 수업을, 한다

이렇게 잘라질 것이다

그렇다면 "수업을, 수업이, 수업에서, 수업은" 전부 다른 단어로 취급 될 것이며,
전부 다르게 벡터화 시킨다면 저장 메모리가 폭발할 것이다

항상 기억하자. 우리의 자원은 한정적이라는 것을..

형태소 단위로 토큰화를 시켜주기 위해 Konlpy라는 라이브러리를 설치해 주자 :)

영화 데이터를 보면 20만개의 데이터가 긍정 1, 부정 0 으로 labeling 되어 있는 것을 확인 할 수 있다

작업 시간 단축을 위해 2만개의 데이터로만 진행해주자 !

cuda GPU를 통해 모델 학습ㅇ르 더 빨리 하기 위해 device를 설정해주고,

konlpy에서 Okt라는 형태소 단위로 토큰화를 하는 인스턴스를 불러왔다

형태소 단위의 토큰화

text라는 변수에 문장을 받아,
text가 str(문자열)이 아니거나, "or not text.strip()" 공백만 있으면

[] 처럼 빈 리스트로 반환해주고,

그게 아니면(정상적으로 통과되면), text를 morphs(형태소) 단위로 토큰화 해주자

문자열을 주어졌을때 이런식으로 토큰화 된 것을 확인하였다

현재 morphs는 단어의 형태를 유지하면서 토큰화 하기 때문에, "했다, 한다, 함, 했음"으로 토큰화가 되었지만,

morphs에 stem = True 라는 파라미터를 넣어주면

"하다"라고 통일되게 토큰화 된 것을 확인할 수 있다

원본 데이터 'document' 에 대해서 preprocess 함수를 사용하여 모든 데이터를 토큰화 해주고 'tokens'라는 칼럼에 저장한다

그리고 토큰화 한 데이터를 ' '(공백 문자)를 기준으로 합쳐준다

-> 기껏 토큰화 시켰는데 왜 다시 join해 줄까?

우리는 뒤에서 TF, TF-IDF 벡터화를 해줄건데 이 라이브러리의 경우 형태소 단위가 아니라, 공백을 기준으로 잘라 버린다.

그러니 "형태소 토큰화 유지 + 벡터화"를 하기 위해 join해 주는 것이다

토큰화 된 'tokens'와 그걸 다시 합친 'joined'

TF(Term Frequency, 단어의 빈도)

한 문서 내에서 특정 단어가 얼마나 자주 등장하는지

: 단어(term)
d: 문서(document)
f(t,d): 문서 에서 단어 가 등장한 횟수

IDF(Inverse Document Frequency)

전체 문서 집합에서 특정 단어가 얼마나 희귀한지

df(t) : 단어 t를 포함하는 문서 수
N : 전체 문서 수

TF - IDF(Term Frequency - Inverse Document Frequency)

문서 내에서는 자주 나오고(TF↑),
전체 문서에서는 드물게 나오는(IDF↑)
단어에 높은 점수를 부여

tf(t, d) : 문서 d안에서 단어 t가 등장한 횟수
df(t) : 단어 t를 포함하는 문서 수
N : 전체 문서 수

VOCAB_SIZE = 5000 : 벡터 단어를 담을 단어장의 최대 크기를 5000개라고 지정
min_df = 3 : 최소 3번 이상 언급된 것만 벡터 단어사전에 남도록

ngram_range=(1,2) :

"재미 없다", "안 좋다" 와 같이 단어가 떨어져 있음으로 인해 단어가 외곡 되거나, 의미가 안 잡히는 문제를 없애기 위해
2단어를 합쳐서 벡터화 시킴!
('기존 형태소 토큰한 단어" + "2개를 합친 n-gram" 모두 벡터화 시키기)

예시 (문장: "이 영화 정말 재미 없다")

1	unigram	이, 영화, 정말, 재미, 없다
2	bigram	이 영화, 영화 정말, 정말 재미, 재미 없다 ← 부정 의미 살아남
3	trigram	이 영화 정말, 영화 정말 재미, 정말 재미 없다

VOCAB_SIZE = 5000개를 어떻게 맞출 것인가?

-> 가장 많이 언급된 단어를 갖고 상위 5000개만을 남기기

TF : CountVectorize(**COMMON_KW)

TF-IDF : TfidfVectorize( **COMMON_KW )

둘다 위에서 만든 **COMMON_KW(고정 최대 크기 지정 + ngram)을 적용하고 있음

학습에선 fit_transform(X_train_text) : 16000개의 리뷰 데이터를 흝으면서 가장 많이 나온 단어 5000개 선정 및 벡터화 + TF or TF-IDF
테스트에선 transform(X_test_text) : 새로운 리뷰 데이터를 통해서 넣어서 TF or TF-IDF

X shape : 16000(train data 리뷰 문서 개수) X 5000(5000개의 벡터 사전)

가장 많이 언급된 5000개 단어 사전

만들어진 5000개의 단어사전

사전을 보면 반복적으로 언급되는 텍스트가 있는 것을 볼 수 있다

첫번째 리뷰 데이터에 대한 TF, IDF, TF-IDF

첫번째 리뷰 문서에서 농구라는 단어가 한 번 언급되었단 것을 볼 수 있다. 회소성에 따른 TF-IDF 값이 높게 설정 되었다는 것을 알 수 있다

MLP 학습 및 평가

MLP 기본 구조를 다른 것과 같이 짜주되, input_dim의 사이즈는 벡터 사전의 사이즈 5000이다(리뷰 한 문서당 들어갈 x의 길이)

CrossEntropy를 사용하여 긍정 리뷰(1), 부정 리뷰(0)을 분류하고 2개의 num_classes에서 logits 값을 출력하도록 설정해준다.

y 데이터의 경우 클래스의 인덱스를 나타내기 때문에 long 타입으로 설정해 준다

model 부분을 .to(device)를 통해서 GPU로 가속화 시켜주고, 배치로 묶은 x와 y값 또한 .to(device)를 해준다

torch.no_grad를 제외하고는 학습과 비슷하다

신기하게도 TF에서 더 좋은 성능을 보였다

리뷰 같은 경우에는 "재밌다. 추천한다"와 같이 비슷한 단어를 많은 사람들이 쓰게 되는데 TF-IDF가 중복 추천된 단어의 가중치를 낮췄기 때문에 이러한 결과가 나온 것 같다고 추측된다

또한 ngram을 통해서 단어의 의미를 합치긴 했지만, 원본 형태소 또한 학습하는 데 사용이 되었으므로,
"재미 없다" 와 "재미" 가 동시에 학습이 되어 의미 충돌이 발생했을 가능성도 있다

딥러닝 CIFAR-10 비정형 이미지 데이터 분류하기(CrossentropyLoss)

justkeepintouch — Mon, 15 Jun 2026 19:00:05 +0900

자동차, 새, 고양이, 사슴 등 10가지 종류의 컬러 이미지 데이터(CIFAR-10) 분류하기
이미지 크기 : 32 x 32 x 3(RGB 3채널)

이번 시간에는 정형 데이터가 아닌, 비정형 데이터(이미지 데이터)를 가지고 멀티 클래스를 분류하는 작업을 할 것이다!

비정형 데이터를 MLP에 학습 시키기 위해선 아래 작업이 우선시 되어야 한다!

이미지 불러와서 MLP의 입력 형태로 바꿔주기
정규화 해주기
불러온 이미지 벡터 -> 1차원으로 Flatten 시키기

데이터 불러오기

Compose : 여러개를 하나로 묶어서 순차대로 실행하도록 하는 객체

ToTensor : 파이토치에서 처리하는 이미지 형식으로 만들어 주기
Normalize : 평균 0이 되도록 정규화 실행
(Lamda x : x.view -1) : 1차원으로 데이터 평탄화 시키기
왜 쉬운 nn.flatten()을 사용하지 않았을까?

-> nn.flatten은 모델의 구성 요소로 넣어서 학습시마다 평탄화 작업을 실행해야 하는데,
위의 compose 코드는 데이터를 불러올 때 전처리 시킴으로써 반복적인 작업을 없앰

train_cifar_dataset[0] : (이미지 데이터, 정답 라벨)
train_cifar_dataset[0][0] : 이미지 데이터 그 자체
train_cifar_dataset[0][0] 크기 : [3072] ( 3 *32 * 32 를 하여 1D로 평탄화 한 후 shape)

데이터 사이즈 확인하기

train_cifar_dataset[0][0]은 train_cifar_dataset.__getitem__(0)[0] 이랑 같은 결과를 나타낸다

train_cifar_dataset[0] -> (이미지, 라벨) 튜플 반환
train_cifar_dataset.__getitem__(0) -> (이미지, 라벨) 튜플 반환
train_cifar_dataset.__getitem__(0)[0] -> 이미지 데이터 반환

하나의 이미지 데이터에 대해 [3072]의 크기르 갖고 내부에 3072개의 픽셀값을 이루고 있다

따라서 input 노드는 3072개가 필요하다

데이터 matplotlib 구조에 맞게 시각화 하기

해당 코드는 이미지 시각화를 위해

1. pythorch 이미지 (채널, 가로, 세로)matplotlib의 input 데이터(세로, 가로, 채널)로 transpose 실행

2. 이미지 데이터 * 표준화 + 평균 실행

하여 시각화를 하였다

MLP 구조 설계하기

MLP에 들아가는

input_size : (채널 *가로*세로 = 3*32*32 = 3072)이다
input.shape : (32, 3072) # 배치, 특징 수
output_size : 10개에 데이터를 분류하기 때문에 output 노드의 개수는 10개이다
output.shape : (32, 10) # 배치, 로짓 수

학습하기

model.to(device) : 모델의 모든 가중치(Weights)를 gpu로 전달

loss function으로 CrossEntropy를 사용

Data_loader 배치마다 새로운 텐서를 CPU에 생성하므로,
todevice 호출을 통해 GPU로 이동시켜 모델과 동일한 장치에서 연산이 이뤄지게 함

평가하기

torch.no_grad() : 평가할 땐 오류 역전파 필요 없으니 기울기 계산 끄
images.to(device), labels.to(device) : 매 반복문 마다 cpu -> gpu로 데이터를 복사하기
torch.max(outputs.data, 1) : loss function으로 CrossEntropy를 사용하였기 때문에
출력은 노드수(10개) 중에 가장 큰 로짓값을 매 bach마다 저장해주기
(outputs.data -> output으로 변경해도 문제 없음)
batch내 예측값과 labels값이 동일한 값만(잘 예측한 값만) correct 변수에 더해주기
(32 + 32 + ... 을 하여 최종적으로 테스트 데이터 개수(1000)만큼 )
labels.size(0) : 모든 이미지의 정답이 담긴 1차원 텐서의 크기 32
ouputs : [32, 10]

학습 디바이스 고르기 CPU vs GPU

cpu와 cuda중 어떤것을 사용할 것인지 인자로 전달

device = torch.device("cuda" if torch.cuda.is_available() else "cpu") :

cuda가 있으면 cuda로 아니면 cpu로

학습, 평가 둘 다 동일 디바이스 활용!

학습할 때: 데이터 → GPU, 모델 → GPU
평가할 때: 데이터 → GPU, 모델 → GPU (모델이 GPU에 있으니까 데이터도 같이 GPU에 있음)

딥러닝 iris 데이터 분류하기 pythorch (BCEWithLogitsLoss vs CrossEntropyLoss 차이)

justkeepintouch — Mon, 15 Jun 2026 10:23:54 +0900

똑같은 irsi 데이터를 갖고 서로 다른 loss를 사용하여 분류하고 성능 비교를 해보자!

BCEWithLogitsLoss :

이진 분류에 사용
output node 개수 : 1개
loss 내부적으로 sigmoid 사용
input 데이터 target y : 2차원 [n,1] 형태 + float( dtype )

CrossEntropyLoss

이진 분류 ~ 다중 분류에 사용
output node 개수 : class 개수만큼
loss 내부적으로 softmax 사용
input 데이터 target y : 1차원 [n] 형태 + long( dtype )

공통 사항 (데이터 불러오기 + train, test 나누기)

우선 iris 데이터를 불러와서 train_test_split를 해준다

(BCEWithLogitsLoss, CrossEntropyLoss 둘 다 동일사항)

Setosa(0)와 Versicolor(1) 중 어떤 품종의 꽃인지 분류하는 문제

데이터 사이즈 (150, 4)

train_test_split : 70% : 30% 비율로 데이터를 나눠주었다

BCEWithLogitsLoss 사용한 MLP

1) Y값 unsqueeze를 통한 차원 늘리기
코드를 보면 y 데이터에 한해서 'unsqueeze(1) : 차원 늘리기' 한 것을 볼 수 있다

BCEWithLogitsLoss 가 2차원 배열의 logits를 받고 loss를 계산하기 때문에,
기존 (105,), (45,) -> (105,1), (45,1)로 변경해 주는 작업이 필요하다

2) output_size : 1개로 설정하기

3개의 layer로 이루어진 간단한 MLP 구조로 설계해 주었다
여기서 중요한 부분은 output size 개수가 1개 인 점이다

2Class로 분류하는데 왜 output node는 1개일까?

BCEWithlogitsLoss는 이진 분류에서 sigmoid를 취하여
확률이 0.5 이상이면 ->1 / 0.5 미만이면 -> 0 으로 분류한다

따라서 2개가 아닌, 1개의 노드만을 사용하여 불필요한 비선형 작업을 줄였다고 볼 수 있다!

4) output_size : logits, labels를 BCEWithLogitsLoss에 전달

100번의 epoch를 돌려서 학습 시키는 코드이다

여기서 outputs 변수는 최종 확률이 아닌, sigmoid 확률로 변환하기 전 값(logits)이다

BCEWithLogitsLoss는 outputs(logits)과 labels를 전달받아
내부적으로 sigmoid를 통한 확률로 변환 후, loss 값을 계산하는 것이다

loss 계산하는 식을 보면 시그마(로짓)을 하는 것을 확인해 볼 수 있다!

그렇다면 왜 sigmoid를 바로하여 확률을 바로 구하지 않고 loss 내부적으로 sigmoid를 시행할까?

=> 마이너스 무한대에 빠지는 안정성 문제 때문이다

이해를 위해 이 코드를 보자.

해당 코드는 사전에 sigmoid한 값을 loss에 넣은 BCELoss 방식과,
BCEWithLoigtsLoss 내부에서 sigmoid를 활용하는 두 개의 안정성 차이를 보여준다

만약 logit 값이 1000.0 이라고 하면

sigmoid(1000.0)은 1에 아주 가까운 숫자가 나온다(float32의 데이터 처리 방식으로 인해 1이라는 숫자가 된다)

sigmoid에 직접 넣을시, loss를 계산하는데 "log(1 - 1) -> 마이너스 무한대"가 되어 모델이 제대로 학습되지 않는다!

반면, BCEWithLoigtsLoss는

내부적으로 sigmoid(로짓)을 하게 되는데, 위에 식은 이해를 위한 식이지 실제로는 수식을 변경하여
log(0)이라는 숫자가 나오지 않도록 안전하게 처리한다!

따라서 안정성을 위해 BCELoss가 아닌, BCEWithLoigtsLoss 방식을 사용할 것을 추천한다

5) 평가

평가 코드에서는 loss 내부에서 확률로 변환하는 것이 아닌,

ouputs(logits)에 sigmoid를 직접 사용하여 확률을 계산하고

이후 round를 통해 반올림하여 0 또는 1로 값을 변경하였다

outputs를 보면 로짓값이 음수 ~ 양수로 나온 것을 볼 수 있는데
predictions(확률 계산 후 클래스로 변환)를 보면 양수는 1, 음수는 0으로 변환 된 것을 확인할 수 있다

이를 통해 ouputs의 logit 값만 보아도, 어떤 클래스로 예측할 것인지 예상할 수 있다!

CrossEntropyLoss

1) Y값 dtype long으로 변경하기

BCEWithLogitsLoss에서는 unsqueeze를 통해서 2D로 변경했던 거와 달리

기존 데이터인 1D 형태로 유지하고, long으로 타입을 변경한다.

CrossEntropyLoss에서는 레이블을 클래스의 인덱스로 받도록 설계되어 있기 때문에 long 타입 변경이 꼭 필요하다

(0번 클래스, 1번 클래스..)

2) Y값 unsqueeze를 통한 차원 늘리기

BCEWithLogitsLoss에서는 output_size를 1로 하여 비선형 계산을 줄였던 것과 달리,
CrossEntropyLoss에서는 class의 개수만큼 output 노드 수를 설계한다

노드 수 증가에 따른 비선형 계산과 파라미터가 늘어났지만,
BCEWithLogitsLoss는 2진 분류밖에 못하는 방면, CrossEntropyLoss는 멀티 클래스 분류가 가능하다!

3) 학습

여기서는 BCEWithLogitsLoss와 똑같이 outputs의 값은 클래스나 확률이 아닌 logit이다

똑같이 outputs, labels를 CrossEntropyLoss에 전달하여 오차를 계산한다.

4) torch.max(outputs, 1)를 통한 가능 큰 로짓을 가진 클래스 인덱스 반환

torch.max(outputs, 1)을 함으로써 해당 로짓에서 가장 큰 값만을 반환하는 것이 아닌,
가장 큰 로짓 + 로짓의 위치 인덱스를 같이 반환한다

_, : 반환한 최대 로짓 값 무시

predicted_classes : 최대 로짓값의 클래스 인덱스가 담긴 1D 텐서 (0, 1, 1 ...)

로짓의 수를 보면 output node의 개수가 2이기 때문에 2클래스씩 로짓값이 나온걸 알 수 있다

2개의 로짓 값 중에 더 큰 로짓값을 가진 클래스의 인덱스를 반환하므로

첫번째는 1번째 클래스, 두번째는 1번째 클래스로 예측된 것을 확인할 수 있다.

분류 loss function 3가지 정리

항목	BCELoss	BCEWithLogitsLoss	CrossEntropyLoss
사용 목적	이진 분류	이진 분류	다중 클래스 분류
입력값	확률(probability)	로짓(logit)	로짓(logit)
내부 Sigmoid	없음	있음	없음
내부 Softmax	없음	없음	있음
출력 노드 수	보통 1개	보통 1개	클래스 수만큼
Target 형태	0 또는 1	0 또는 1	클래스 인덱스 (0,1,2...)
모델 마지막 층	Sigmoid 필요	Linear 그대로	Linear 그대로
수식	BCE(p,y)	Sigmoid→BCE	Softmax→NLL
수치 안정성	낮음	높음	높음
실무 사용	거의 안 씀	가장 많이 사용	다중분류 표준

주피터 노트북, 코랩 matplotlib 그래프 시각화할때 한국어 깨짐 현상 해결 방법!

justkeepintouch — Mon, 8 Jun 2026 17:23:04 +0900

그래프를 시각화 하다보면 해당 그림처럼 한국어 부분이 네모 낳게 표시되어 정상적으로 출력되지 않을 것을 볼 수 있다

이때 gemini를 돌려보면 한국어 txt를 설치해주는 코드를 주는데 한국어 텍스트를 깔고 어떤짓을 해도 한국어가 출력되지 않는다

ㅡㅡ,,,

해결 방법!

코드 두줄을 넣어주기!

pip install koreanize_matplotlib

import koreanize_matplotlib

이후 한국어가 잘 출력되는 것을 확인

다만 귀찮은 점.

코랩에서 실행시 매 파일마다 koreanize_matplotlib 라이브러리를 설치해줘야함

선형(linear)과 비선형(nonlinear) 함수의 오해와 진실 [인공지능]

justkeepintouch — Mon, 8 Jun 2026 16:36:51 +0900

오해1 : 선형 모델의 그래프는 항상 직선이다?

진실1 : 그래프 모양은 곡선일 수도 있다

선형성은 그래프의 모양이 아니라 모델의 파라미터가 선형적으로 결합되는지에 의해 결정된다.

y = 2x^2 + 3의 경우 곡선의 모양을 띠고 있으나, 선형 회귀로 학습할 수 있다.

ex) 선형 회귀

y=w0+w1x+w2x2+w3x3

그래프를 보면 곡선의 형태를 띄고 있으나,

w0, w1, w2, w3에 대한 가중치에선 여전히 선형선을 띄고 있음!

비선형 함수

왼쪽 ) 시그모이드 함수 / 오른쪽 ) ReLU 함수

그외 여러 지수함수, 로그함수, 절대값 함수

비선형 모델

y=w0+w1^2x
y=sin(w1x)
y=e^w1x

파라미터(가중치 w)가 제곱이 되거나, 지수함수에 들어가는 등 비선형성을 띔 -> 비선형 모델

오해 2 : 선형 모델은 복잡한 패턴을 학습하지 못한다?

진실 2 : Feature Engineering을 사용하면 선형 모델도 복잡한 곡선 패턴을 학습할 수 있다.

x (원본 특성)
-> x² (추가 특성)
-> x³ (추가 특성)

x의 차수를 변경해서 복잡한 패턴을 학습할 수 있도록 그래프 모양을 만들어줌

왼쪽) 그래프는 데이터와 not fit한 상태임 / 오른쪽) x², x³ 등의 특성을 추가하여 곡선 패턴에 맞게 학습한 결과

BUT ! 해당 방법을 잘 사용하지 않는다

사람이 데이터에 적합한 모델을 함수로 직접 만들어야 한다(다항식을 직접 꾸며야 함)
사람이 하기 때문에 시간, 비용이 많이 든다
변수가 늘어남에 따라 특성 수가 증가하여 현실적인 불가능

=> 따라서 AI에서는 Feature Engineering을 수동으로 수행하기보다, 비선형 모델을 사용하여 자동으로 학습하도록 한

c++ (생성자 멤버 초기화 리스트 / 디폴트 매개변수 / 함수 초기화 / 생성자 호출) 헷갈리는 문법 한 번에 정리!

justkeepintouch — Mon, 2 Jun 2025 23:45:25 +0900

c++ 언어의 경우 java 언어와는 달리 허용하는 문법이 많은데 그러다 보니 오히려 여러 가지 문법 사이에 어떤 걸 사용해야 하는지 혼돈이 오기 쉽다..

나의 경우 생성자를 초기화할 때 {} 안에 대입하여 초기화하는 것과 리스트로 초기화 하는 방식이 초반에 헷갈렸고

디폴트 매개변수를 사용하면서 기본 생성자와 파라미터 있는 생성자를 합치는 방식.

main함수에서 사용자로 부터 입력값을 받고 해당 객체에 저장하는 방식 등이 헷갈렸다

헷갈릴 때 마다 GPT를 사용하면서 이해했다고 생각하며 넘어갔더니 매번 같은 부분에서 막히는 나 자신을 발견하였다

쉽게 얻은 건 뇌에서 쉽게 사라지는 거 같다

명품 c++ 9장에선 virtual 가상함수를 사용하여 재정의하는 다형성에 대해서 설명하고 있다

예제 9-4를 오른쪽의 조건에 맞게 변환하는 문제가 내 발몫을 잡았다

문제의 조건을 정리해 보면

더보기

Shape 클래스를 상속받는 Circle, Rect 클래스 구현
더보기

각 클래스에 다음 멤버 변수:
Circle → int radius

Rect → int width, int height
더보기

draw() 함수에서는:
기본 클래스 Shape::draw() 먼저 호출

그다음 Circle(radius: XX), Rect(width: XX, height: YY) 형식 출력
더보기

Circle, Rect 생성자는 디폴트 파라미터를 사용하고 기본값은 1
더보기

main()에서는 Circle, Rect 객체 선언 후 사용자 반지름, 너비, 높이 입력으로 값 받기(양수가 입력될 때까지)
더보기

Shape* pShape로 업캐스팅 후 draw() 호출

조건 1,2를 보면 우선적으로 Rect 클래스를 먼저 만들어주고,

Circle과 Rect가 Shape의 상속을 private으로 받게 해 준 후,

클래스 내부에 private으로 변수를 정의해 준다

이후 조건 3의 출력 형태에 맞게 cout << 형식을 조정해 준다

class Shape {
public:
	virtual void draw() {
		cout << "--shape--";
	}
};

class Circle :public Shape { // -> **조건1** public 으로 shape 클래스 상속받기
	int radius; // -> **조건2** int radius 변수 private으로 정의
public:
	virtual void draw() {
		Shape::draw();
		cout << "Circle (radius: " << radius << ")" << endl; // -> **조건3** 출력 형태 맞춰주기
	}
};

class Rect :public Shape { // -> **조건1** public 으로 shape 클래스 상속받기
	int width, height; // -> **조건2** int width, int height 변수 private으로 정의
public:
	virtual void draw() {
		Shape::draw();
		cout << "Rect (width: " << width << ",height: " << height << ")" << endl;
        // -> **조건3** 출력 형태 맞춰주기
	}
};

그다음 조건부터 헷갈리는 영역이 나오는데
조건 4의 디폴트 파라미터를 사용하고 기본 값이 1이라는 것은 (파라미터가 없는 생성자 + 파라미터가 있는 생성자 = 1)로 합치라는 것이다

이게 무슨 말이냐?!

Circle() {} // 기본 생성자
Circle(int radius) { this->radius = radius; } // 매개변수 생성자

원래는 이런 식으로 기본 생성자와 매개변수 생성자 나눠서 작성하지만

Circle(int radius = 1) { this->radius = radius; } // 디폴트 매개 변수 기본값 1

이런 식으로 코드를 합치게 되면 Circle circle; 코드를 작성할 때 Circle()이라는 생성자가 호출되게 되는데 radius = 1로 자동 대입하게 된다. 말 그대로 생성자 호출할 때 값을 생략해도 default로 값은 1이라는 의미이다.

또한 생성자를 초기화하는 방법은 2가지가 있는데
{} 안에 코드를 작성하며 초기화하는 일반대입 방식과,

리스트 방식으로 초기화하는 생성자 초기화 리스트 방식이 있다.

class Circle {
	int radius;
public:
	Circle(int r) { radius = r; } // 일반 대입
    Circle(int r) : radius(r) {} // 생성자 초기화 리스트
};

어떠한 방식을 사용해도 결과는 같지만 생성자 초기화 리스트 방식으로 사용하면 좀 더 안정적으로 빠르게 코딩할 수 있다는 장점이 있다.

이로써 클래스 및 외부함수 정의는 끝났다!

#include <iostream>
using namespace std;

class Shape {
public:
	virtual void draw() {
		cout << "--shape--";
	}
};

class Circle :public Shape { // 조건1
	int radius; // 조건2
public:
	Circle(int radius = 1) : radius(radius) {} // 조건4
	virtual void draw() {
		Shape::draw();
		cout << "Circle (radius: " << radius << ")" << endl; // 조건3
	}
};

class Rect :public Shape { // 조건 1
	int width, height; // 조건2
public:
	Rect(int width = 1, int height = 1) : width(width), height(height) {} // 조건4
	virtual void draw() {
		Shape::draw();
		cout << "Rect (width: " << width << ",height: " << height << ")" << endl; // 조건3
	}
};

이제 조건 5의 main() 함수 정의를 하면 되는데
사용자로부터 반지름, 너비, 높이 값을 양수일 때까지 반복적으로 받아야 하기 때문에

int main() {
	int radius, width, height; // 사용자 입력에 받을 변수 미리 선언
    
	while (1) {
		cout << "반지름, 너비, 높이를 입력하시오: ";
		cin >> radius >> width >> height;

		if (radius > 0 && width > 0 && height > 0) {
			break;
		}
	}

	Circle circle(radius);
	Rect rect(width, height); 
}

while문을 사용해서 양수일 때 반복문을 빠져나오게 정의해 주면 된다!

(사용자로부터 입력받을 변수 radius, width, height을 전부 0으로 초기화해 주면 좀 더 안전하게 사용 가능하다)

또한 받은 값을 토대로 출력하기 객체를 생성하면서 값을 넣어주면 된다! -> -- 삐 -- 코드상으론 오류가 없지만 조건 5에 맞지 않음!!

조건 5를 다시 보자!

main()에서는 Circle, Rect 객체 선언후 사용자 반지름, 너비, 높이 입력으로 값 받기(양수가 입력될 때 까지)

내가 작성한 코드에선 입력받은 값을 토대로 객체를 선언하고 있는데 조건에선 일단 객체를 선언하고 입력을 받으라고 했다

int main() {
	int radius, width, height; // 사용자 입력에 받을 변수 미리 선언
    
    Circle circle(radius);
	Rect rect(width, height); 
    
	while (1) {
		cout << "반지름, 너비, 높이를 입력하시오: ";
		cin >> radius >> width >> height;

		if (radius > 0 && width > 0 && height > 0) {
			break;
		}
	}
}

그렇다고 해서 이런 식으로 코드를 상단에 올린다면 radius, width, height 값은 입력받기 전이므로 오류가 발생하고

int main() {
	int radius = 0, width = 0, height = 0;

	Circle circle; // 객체 선언
	Rect rect; // 객체 선언

	while (1) {
		cout << "반지름, 너비, 높이를 입력하시오: ";
		cin >> radius >> width >> height;

		if (radius > 0 && width > 0 && height > 0) {
			break;
		}
	}

	Circle circle(radius); // 객체 재정의!
	Rect rect(width, height); // 객체 재정의!
}

이런 식으로 객체를 두 번 선언해 버리면 객체 재정의 오류가 난다

따라서 받은 값을 가장 안전하게 저장할 수 있는 set 함수를 사용하여 Circle과 Rect 각각의 클래스에 정의해 주는 것이다

다시 외부 함수를 수정하면

class Circle :public Shape {
	int radius;
public:
	Circle(int radius = 1) : radius(radius) {}
	void setRadius(int radius) { this->radius=radius; } // set함수 정의
	virtual void draw() {
		Shape::draw();
		cout << "Circle (radius: " << radius << ")" << endl;
	}
};

class Rect :public Shape {
	int width, height;
public:
	Rect(int width = 1, int height = 1) : width(width), height(height) {}
    void set(int width, int height) { his->width = width; this->height = height; } // set함수 정의
	virtual void draw() {
		Shape::draw();
		cout << "Rect (width: " << width << ",height: " << height << ")" << endl;
	}
};

Circle과 Rect 각각에 정의한 set 함수는 이러하다

따라서 이제 main 함수에는 각각의 객체로 접근한 뒤 사용자로부터 입력받은 값을 넣어 함수를 호출하면 된다

int main() {
	int radius = 0, width = 0, height = 0;

	Circle circle; // 객체 선언
	Rect rect; // 객체 선언

	while (1) {
		cout << "반지름, 너비, 높이를 입력하시오: ";
		cin >> radius >> width >> height;

		if (radius > 0 && width > 0 && height > 0) {
			break;
		}
	}

	circle.set(radius); // set함수 호출
	rect.set(width, height); // set함수 호출
}

이런 식으로 말이다!

이제 정말 끝이 보인다

조건 6번만 해결하면 된다

Shape* pShape로 업캐스팅 후 draw() 호출

업캐스팅이라는 의미를 알려면 상속에 대해서 잘 알고 있어야 하는데

코드를 보면 Shape은 기본 클래스이고 Circle과 Rect는 상속을 받는 파생 클래스임을 알 수 있다

업캐스팅이라는 것은 기본 클래스의 포인터가 파생 클래스 객체의 주소를 갖는 것인데

코드를 통해 보면 이러하다

Shape* pShape = &circle; // 업캐스팅

Shape* pShape = &rect; // 업캐스팅

*여기서 주의할 점은 업캐스팅한 포인터는 기본 클래스의 함수만 호출할 수 있다는 점이다

그러나 우리가 호출하고자 하는 최종적인 draw() 함수는 가상함수 이기 때문에 기본 클래스가 아닌, 오버라이딩한 파생 클래스의 draw()가 런타임 중 실행될 것이라는 것을 짐작할 수 있다!!

최종적으로 완성된 코드는 이러하다

#include <iostream>
using namespace std;

class Shape {
public:
	virtual void draw() {
		cout << "--shape--";
	}
};

class Circle :public Shape {
	int radius;
public:
	Circle(int radius = 1) : radius(radius) {}
	void set(int radius) { this->radius=radius; }
	virtual void draw() {
		Shape::draw();
		cout << "Circle (radius: " << radius << ")" << endl;
	}
};

class Rect :public Shape {
	int width, height;
public:
	Rect(int width = 1, int height = 1) : width(width), height(height) {}
	void set(int width, int height) { this->width = width; this->height = height;
	}
	virtual void draw() {
		Shape::draw();
		cout << "Rect (width: " << width << ",height: " << height << ")" << endl;
	}
};

int main() {
	int radius = 0, width = 0, height = 0;

	Circle circle; // 객체 선언
	Rect rect; 

	while (1) {
		cout << "반지름, 너비, 높이를 입력하시오: ";
		cin >> radius >> width >> height;

		if (radius > 0 && width > 0 && height > 0) {
			break;
		}
	}

	circle.set(radius);
	rect.set(width, height);

	Shape* pShape = &circle; // 업캐스팅
	pShape->draw();

	pShape = &rect; // 업캐스팅
	pShape->draw();
}

정상 출력 확인!

이로써 애매한 지식 때문에 느꼈던 불편함에서 잠시나마 해방되었다.

24.04 LTS 우분투 실행중 프리징 현상(멈춤 현상)해결하기 생각보다 간단하게 해결

justkeepintouch — Mon, 10 Mar 2025 07:26:10 +0900

우선 24.04 LTS란 : 오랜 기간 동안 보안 및 안정성 업데이트를 제공하여 가장 안전한 버전이라고 보면 된다!

따라서 우선 우분투를 깔때 이걸로 깔기 추천

신나게 Oracle VirtualBox 깔고 우분투를 설치하려는데 자꾸만 화면이 멈추는 프리징 현상을 발견했다

아래 화면에서 다음으로 넘어가질 않음...

우분투과 고군분투... 이때 별의별 생각이 다듦

구글에 "우분투 프리징 현상"을 검색하면

"그래픽끼리의 충돌 현상으로 인한 문제 해결 글"이 대부분인데 쉽게 말하자면,

우분투에서 기본적으로 NVIDIA드라이버를 사용하는데,
NVIDIA 드라이버의 Nouveau라는 것이 GPU를 옳바르게 지원하지 못해 충돌이 생기는 것이다

해결 방법 :

일시적으로 그래픽 카드 사용을 막은후 최적의 공식 그래픽 적용해주기

1. GRUB 편집기(e 누르면 편집 상태로 들어감)에서 quiet splash 옆에 nomodeset 을 적고 ctrl + x (재부팅)를 눌러줌
커널이 부팅중에 그래픽카드 직접 제어하는 걸 막아줌

e키를 눌러 GRUB 편집 모드로 진입후 -> nomodeset 입력 후 ctrl + x (재부팅)

2. 그래픽 제어를 막았으니 두번째로 최상의 NVIDIA 공식 드라이버 설치해서 적용해주면 됨

당연히 그래픽 문제인줄 알고 위에 행위를 몇 시간 동안 했으나 해결되지 않았다!! 여전히 같은 부분에서 멈춤

이거 해결 못하면 네프밍 수업에서 실습 못한다는 생각에 무서워서 밤새 서칭한 결과....

CPU 코어, RAM(메모리), 비디오 메모리, 3D 가속 체크 유무의 문제였음...!

RAM(메모리) : 최소 4GB이상(여유 있으면 8GB 추천)
하드디스트 : 가장 상단으로 올리기
CPU : 4개 이상
Videao Memory : 128MB
Enable 3D : 사용 선택

RAM(메모리) : 최소 4GB이상(여유 있으면 8GB 추천) 하드디스크 : 가장 상단으로 올리기

CPU : 4개 이상

Videao Memory : 128MB Enable 3D : 사용 선택

짜짠 그후 우분투가 잘 설치됨!

*느낀점 :
어쩌면 가장 기본적인 사항으로 더 빠르게 해결할 수 있는 문제였을 수도 있다.
오류를 해결하고 나니 운영체제 첫 강의자료에 적힌 '기본이 가장 중요하므로 너무 조급하게 생각하지 말고 기본을 탄탄히 할 것'이란 글이 떠올랐다.

DON'T PANIC!