해색주의 조용한 공간

Mac M1에서 Visual Studio Code를 사용해 2D 게임을 개발하려면, 아래와 같은 환경을 추천해!

추천 라이브러리

1. SDL2 (Simple DirectMedia Layer)
   • 크로스플랫폼 지원, 성능 좋고 학습 곡선이 낮음.
   • 2D 게임 개발에 최적.
2. SFML (Simple and Fast Multimedia Library)
   • C++ 기반, 코드가 간결해서 배우기 쉬움.
   • 그래픽, 사운드, 입력 처리가 간편함.
3. Raylib
   • 경량 2D/3D 게임 개발 라이브러리.
   • C 기반이지만 C++에서도 사용 가능.

➡ SDL2를 추천! 이유는 M1에서도 안정적으로 동작하고, 자료가 많아서 배우기 좋아.

개발 환경 설정 (Mac M1 + VS Code + SDL2)

1. Homebrew 설치 확인
2. sh
   복사편집
   brew update brew install sdl2 sdl2_image sdl2_mixer sdl2_ttf
3. VS Code 설정
   • C++ Extension Pack 설치
   • CMake & Make 설치 (brew install cmake make)
4. 간단한 SDL2 코드 (C++) 아래 코드를 main.cpp로 저장하고 실행하면 윈도우와 빨간색 배경을 가진 2D 화면이 표시돼.

#include <SDL2/SDL.h>
#include <iostream>

int main(int argc, char* argv[]) {
    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
        std::cout << "SDL 초기화 실패: " << SDL_GetError() << std::endl;
        return -1;
    }

    SDL_Window* window = SDL_CreateWindow("SDL2 2D Game", 
                                          SDL_WINDOWPOS_CENTERED, 
                                          SDL_WINDOWPOS_CENTERED, 
                                          800, 600, 
                                          SDL_WINDOW_SHOWN);
    if (!window) {
        std::cout << "윈도우 생성 실패: " << SDL_GetError() << std::endl;
        SDL_Quit();
        return -1;
    }

    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    if (!renderer) {
        std::cout << "렌더러 생성 실패: " << SDL_GetError() << std::endl;
        SDL_DestroyWindow(window);
        SDL_Quit();
        return -1;
    }

    bool isRunning = true;
    SDL_Event event;

    while (isRunning) {
        while (SDL_PollEvent(&event)) {
            if (event.type == SDL_QUIT) {
                isRunning = false;
            }
        }

        SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);  // 빨간색 배경
        SDL_RenderClear(renderer);
        SDL_RenderPresent(renderer);
    }

    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();
    return 0;
}

4. 컴파일 및 실행 (Mac M1 기준)

 나름 열심히 공부했다고 생각했는데, 아침에 유튜브를 봐서 그나마 과락을 면한 것 같다. 다음에 1차 준비할 때에는 강의를 좀더 열심히 듣고 나서 시험 봐야겠다는 생각이 드네. 그래도 합격한게 어디냐 ㅎㅎ

이직한지 만3년이 지났다. 헤보고 싶은 일이 있어서 나왔다는 거창한 이야기와는 달리 재취업이 쉽지 않았다. 다행히 전문계약직으로 재취업이 되어서 금융권 빅데이터부서에서 데이터분석가로 일하고 있다.

 작년 한 해동안 같이 일할 직원 채용하느라 많은 분들의 이력서를 읽어봤고 면접에 참여했다. 

 회사에서도 몇 번이나 채용을 하려고 했지만, 최종 협상중에 결렬이 되는 경우가 몇 번 있었고 이번에 마지막에 결렬되었다. 새로운 팀장님이 오면서 다행히 업무도 많이 늘어났고 복잡한 분석 업무를 많이 하면서 팀의 업무에 과부하가 오기 시작했다. 사실 나는 작년 하반기부터 업무에 부하가 와서 거의 매달 야근을 꽉꽉 채워서 일을 해야만 했다. 매번 새로운 타입의 일을 하기 때문에 기존 코드를 재활용하기 힘들었고 모델링 업무도 끝나서 새로운 일을 계속해야 하는 상황이다.

 일을 열심히 하는데 혼자서 다하기는 어렵다.

 일을 잘하는 사람들은 여기저기 면접도 많이 보고, 뛰어난 사람들은 잘 팔린다는 생각이 든다. 그나저나 올해에는 외부 채용을 할 수 있을지 모르겠다.

금요일 하루 출근이기는 한데 무척이나 부담스럽기는 하다. 아픈 거는 좀 나아졌고, 이제 당분간은 무리하지 말아야지.

아래는 주어진 조건에 따라 모델을 구현한 Python 코드와 총 파라미터 개수를 계산한 결과입니다:

모델 구현

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, SimpleRNN, Dense

# 모델 파라미터
vocab_size = 5000          # 단어 집합 크기
embedding_dim = 100        # 임베딩 벡터 차원
sequence_length = 30       # 샘플 길이
hidden_units = 128         # SimpleRNN 은닉 상태 크기

# 모델 생성
model = Sequential([
    Embedding(input_dim=vocab_size, output_dim=embedding_dim, input_length=sequence_length),
    SimpleRNN(units=hidden_units, activation='tanh'),
    Dense(1, activation='sigmoid')
])

# 모델 요약 출력
model.summary()

총 파라미터 계산

1. Embedding Layer:
   • vocab_size×embedding_dim=5000×100=500,000\text{vocab\_size} \times \text{embedding\_dim} = 5000 \times 100 = 500,000vocab_size×embedding_dim=5000×100=500,000
2. SimpleRNN Layer:
   • SimpleRNN의 파라미터 계산 공식: RNN 파라미터 수=(input_dim+units+1)×units\text{RNN 파라미터 수} = (\text{input\_dim} + \text{units} + 1) \times \text{units}RNN 파라미터 수=(input_dim+units+1)×units 여기서,
     • input_dim=embedding_dim=100\text{input\_dim} = \text{embedding\_dim} = 100input_dim=embedding_dim=100
     • units=128\text{units} = 128units=128
     • 111은 bias 항목
     (input_dim+units+1)×units=(100+128+1)×128=229×128=29,312(\text{input\_dim} + \text{units} + 1) \times \text{units} = (100 + 128 + 1) \times 128 = 229 \times 128 = 29,312(input_dim+units+1)×units=(100+128+1)×128=229×128=29,312
3. Dense Layer:
   • units_in×units_out+bias=128×1+1=129\text{units\_in} \times \text{units\_out} + \text{bias} = 128 \times 1 + 1 = 129units_in×units_out+bias=128×1+1=129

총 파라미터

• Embedding Layer: 500,000
• SimpleRNN Layer: 29,312
• Dense Layer: 129
• 총 파라미터: 500,000+29,312+129=529,441500,000 + 29,312 + 129 = 529,441500,000+29,312+129=529,441

출력

model.summary()를 실행하면 다음과 유사한 출력이 나타납니다:

Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 embedding (Embedding)       (None, 30, 100)          500000    
                                                                 
 simple_rnn (SimpleRNN)      (None, 128)              29312     
                                                                 
 dense (Dense)               (None, 1)                129       
                                                                 
=================================================================
Total params: 529,441
Trainable params: 529,441
Non-trainable params: 0
_________________________________________________________________

아래는 주어진 조건을 만족하는 PyTorch 기반 모델 구현 코드입니다.

import torch
import torch.nn as nn

class SimpleRNNBinaryClassifier(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_units):
        super(SimpleRNNBinaryClassifier, self).__init__()
        self.embedding = nn.Embedding(num_embeddings=vocab_size, embedding_dim=embedding_dim)
        self.rnn = nn.RNN(input_size=embedding_dim, hidden_size=hidden_units, batch_first=True)
        self.fc = nn.Linear(in_features=hidden_units, out_features=1)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        # Embedding layer
        x = self.embedding(x)  # Shape: (batch_size, sequence_length, embedding_dim)
        # RNN layer
        output, hidden = self.rnn(x)  # hidden has shape (1, batch_size, hidden_units)
        # Fully connected layer
        x = self.fc(hidden.squeeze(0))  # Shape: (batch_size, 1)
        # Sigmoid activation
        x = self.sigmoid(x)
        return x

# 모델 파라미터
vocab_size = 5000
embedding_dim = 100
sequence_length = 30
hidden_units = 128

# 모델 생성
model = SimpleRNNBinaryClassifier(vocab_size, embedding_dim, hidden_units)

# 모델 요약 출력 (파라미터 개수 포함)
print(model)

# 총 파라미터 개수 계산
total_params = sum(p.numel() for p in model.parameters())
print(f"Total parameters: {total_params}")

주요 변경점

1. Embedding Layer:
   • nn.Embedding을 사용하여 단어 집합 크기와 임베딩 벡터 차원 설정.
2. SimpleRNN Layer:
   • nn.RNN을 사용하여 은닉 상태 크기와 입력 크기 정의.
   • batch_first=True를 설정해 입력 텐서를 (batch_size, sequence_length, embedding_dim) 형태로 맞춤.
3. Dense Layer:
   • nn.Linear을 사용해 은닉 상태의 마지막 출력에서 1차원 출력 생성.
4. Sigmoid Activation:
   • 이진 분류 문제를 위해 nn.Sigmoid를 적용.

출력 예시

위 코드를 실행하면 모델 구조와 총 파라미터 개수를 확인할 수 있습니다.

예:

SimpleRNNBinaryClassifier(
  (embedding): Embedding(5000, 100)
  (rnn): RNN(100, 128, batch_first=True)
  (fc): Linear(in_features=128, out_features=1, bias=True)
  (sigmoid): Sigmoid()
)
Total parameters: 529441