Leeparang Archive

IRIS - Machine Learning Study · 3차시

Tue, 22 Sep 2026 00:00:00 GMT

1. 자연어 처리란?

사람이 사용하는 언어를 컴퓨터가 이해하고 처리하도록 만드는 기술

예시) 번역기, 챗봇, 스팸 메일 분류, 문서 요약

2. 자연어 처리 과정

문장 입력 → 전처리 → 숫자로 변환 → 모델 학습 → 결과 예측

1. 문장 입력
분석할 말이나 글을 컴퓨터에 입력한다.
예: “이 영화 정말 재미있다!”

2. 전처리
문장을 분석하기 좋은 형태로 정리합니다. 필요에 따라 불필요한 기호를 제거하고, 문장을 작은 단위인 토큰으로 나눈다.
예: 이 / 영화 / 정말 / 재미있다

3. 숫자로 변환
컴퓨터가 계산할 수 있도록 토큰을 숫자나 숫자들의 묶음인 벡터로 바꿉니다. 단어의 의미와 관계를 벡터로 표현하는 방법을 임베딩이라고 한다.
예: 영화 → [0.2, -0.4, 0.7, …]

4. 모델 학습
많은 문장과 정답을 보여주고, 예측이 정답에 가까워지도록 모델의 내부 값을 조정한다.
예: “재미있다” → 긍정, “지루하다” → 부정
이 과정을 반복하면서 학습한다.

5. 결과 예측
학습한 모델이 새로운 문장을 분석해 결과를 낸다.
예: “정말 재미있어서 다시 보고 싶다” → 긍정

학습이 끝난 모델을 사용할 때는 매번 다시 학습하지 않고, 새 문장 입력 → 전처리 → 숫자로 변환 → 학습된 모델로 예측하는 과정을 거친다고 한다.

3. 텍스트 전처리

컴퓨터가 문장을 분석하고 학습하기 쉽도록 불필요한 부분을 정리하고, 처리하기 좋은 형태로 바꾸는 과정

(1) 토큰화: 문장을 단어나 의미를 가진 작은 단위로 나누는 방법

예) "이 영화 정말 재미있다" → ["이", "영화", "정말", "재미있다"]

(2) 텍스트 정규화: 같은 의미의 표현을 일정한 형태로 정리하는 방법

예) "IRISㅋㅋ" → "IRIS"
특수문자나 불필요한 표현을 제거할 수 있다.

4. 형태소 분석

문장을 의미를 가진 가장 작은 단위인 형태소로 나누고, 각 형태소의 품사와 역할을 분석하는 방법

예) “현우는 아프다” → 현우 / 는 / 아프 / 다

한국어는 조사와 어미가 붙어 단어의 형태가 다양하게 바뀌기 때문에, 문장의 구조와 의미를 파악하는 데 형태소 분석이 중요하다.

5. 벡터화

머신러닝 모델은 글자를 그대로 이해하거나 계산하기 어렵다.

그래서 단어나 문장을 컴퓨터가 처리할 수 있는 숫자의 배열(벡터)로 바꾸어야 이해하고, 계산 할 수 있다.

이 과정을 벡터화라고 부른다.

예) “현우는 아프다” → [0.2, 0.7, -0.3, …]

벡터화를 통해 컴퓨터는 단어의 의미와 단어 사이의 관계를 학습할 수 있다.

6. Bag of Words

문장에 각 단어가 몇 번 등장했는지를 세어 숫자로 표현하는 벡터화 방법

예)

문장: “나는 영화가 좋다 나는 행복하다”
단어 목록: [나는, 영화가, 좋다, 행복하다]
벡터: [2, 1, 1, 1]

(1) 장점: 구조가 간단하고 이해하기 쉬움

(2) 단점: 단어의 순서와 문맥을 반영하기 어려움

7. TF-IDF

특정 문서에는 자주 등장하지만, 다른 문서에서는 드물게 등장하는 단어에 더 높은 중요도를 부여하는 벡터화 방법

TF: 한 문서에서 특정 단어가 등장하는 빈도

IDF: 전체 문서에서 특정 단어가 얼마나 드문지를 나타내는 값

문서의 핵심 내용이나 특징을 나타내는 단어를 찾는 데 활용

8. 실습

자연어 처리 Colab 실습

(1) 라이브러리 불러 오기

# 셀 1. 라이브러리 불러오기

import re # 특수문자 제거
import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression

print("라이브러리 불러오기 완료!")

셀 1에서는 자연어 처리와 머신러닝에 필요한 라이브러리를 불러온다. re는 문장에 포함된 특수문자를 제거하는 데 사용하고, pandas는 데이터를 표 형태로 정리하고 처리하는 데 사용한다. TfidfVectorizer는 텍스트를 TF-IDF 방식의 숫자 벡터로 변환하며, LogisticRegression은 변환된 데이터를 학습하고 문장을 분류하는 모델이다. 마지막으로 print()를 사용해 라이브러리를 정상적으로 불러왔다는 메시지를 출력한다.

(2) 학습 데이터

# 셀 2. 학습 데이터

positive_texts = [
    "정말 좋다",
    "정말 마음에 든다",
    "너무 만족스럽다",
    "아주 훌륭하다",
    "정말 잘했다",
    "최고였다",
    "매우 좋았다",
    "잘한 것 같다",
    "정말 괜찮다",
    "생각보다 좋다",

    "다시 뽑고 싶다",
    "다음에도 뽑고 싶다",
    "다시 함께하고 싶다",
    "다음에도 같이 활동하고 싶다",
    "같이 활동해서 즐거웠다",
    "함께해서 좋았다",
    "다시 만나고 싶다",
    "계속 같이하고 싶다",

    "좋은 부원이다",
    "훌륭한 부원이다",
    "믿을 만한 부원이다",
    "책임감 있는 부원이다",
    "성실한 부원이다",
    "열심히 하는 부원이다",
    "적극적인 부원이다",

    "책임감 있게 행동했다",
    "맡은 일을 잘했다",
    "맡은 일을 끝까지 해냈다",
    "자신의 역할을 잘 수행했다",
    "활동에 열심히 참여했다",
    "활동에 적극적으로 참여했다",
    "프로젝트에 적극적이었다",
    "팀 활동에 열심히 참여했다",

    "팀에 도움이 되었다",
    "팀에 많은 도움이 되었다",
    "팀원들에게 도움이 되었다",
    "프로젝트에 큰 도움이 되었다",
    "좋은 결과를 만들었다",
    "결과가 만족스럽다",
    "결과가 매우 좋았다",

    "실력이 좋다",
    "실력이 뛰어나다",
    "능력이 좋다",
    "잘하는 것 같다",
    "생각보다 잘한다",
    "기대 이상으로 잘했다",

    "태도가 좋았다",
    "성격이 좋다",
    "친절하다",
    "협력을 잘한다",
    "의사소통을 잘한다",

    "현우는 정상적이다",
    "현우는 정말 괜찮다",
    "도근이의 관제탑은 최고였다",
    "도근이는 정말 잘했다",
    "예건이는 마음에 들었다",
    "예건이는 정말 좋았다"
]

negative_texts = [
    "정말 싫다",
    "정말 마음에 안 든다",
    "너무 실망스럽다",
    "아주 별로다",
    "정말 못했다",
    "최악이었다",
    "매우 좋지 않았다",
    "못한 것 같다",
    "정말 별로다",
    "생각보다 안 좋다",

    "다시 뽑고 싶지 않다",
    "다음에는 뽑고 싶지 않다",
    "다시 함께하고 싶지 않다",
    "다음에는 같이 활동하고 싶지 않다",
    "같이 활동하기 힘들었다",
    "함께해서 힘들었다",
    "다시 만나고 싶지 않다",
    "계속 같이하고 싶지 않다",

    "좋은 부원이 아니다",
    "훌륭한 부원이 아니다",
    "믿기 어려운 부원이다",
    "책임감 없는 부원이다",
    "성실하지 않은 부원이다",
    "열심히 하지 않는 부원이다",
    "소극적인 부원이다",

    "책임감 없이 행동했다",
    "맡은 일을 못했다",
    "맡은 일을 끝내지 않았다",
    "자신의 역할을 제대로 수행하지 않았다",
    "활동에 제대로 참여하지 않았다",
    "활동에 소극적으로 참여했다",
    "프로젝트에 소극적이었다",
    "팀 활동에 참여하지 않았다",

    "팀에 도움이 되지 않았다",
    "팀에 별로 도움이 되지 않았다",
    "팀원들에게 피해를 줬다",
    "프로젝트에 도움이 되지 않았다",
    "좋지 않은 결과를 만들었다",
    "결과가 실망스럽다",
    "결과가 매우 좋지 않았다",

    "실력이 부족하다",
    "실력이 좋지 않다",
    "능력이 부족하다",
    "잘하지 못하는 것 같다",
    "생각보다 못한다",
    "기대 이하로 못했다",

    "태도가 좋지 않았다",
    "성격이 좋지 않다",
    "불친절하다",
    "협력을 잘하지 않는다",
    "의사소통을 잘하지 않는다",

    "현우는 아프다",
    "현우는 정말 별로다",
    "도근이의 관제탑은 최악이었다",
    "도근이는 정말 못했다",
    "예건이는 마음에 안 들었다",
    "예건이는 정말 별로였다"
]

texts = positive_texts + negative_texts

labels = (
    [1] * len(positive_texts) +
    [0] * len(negative_texts)
)

print("전체 데이터:", len(texts))
print("긍정 데이터:", labels.count(1))
print("부정 데이터:", labels.count(0))

셀 2에서는 모델을 학습시키기 위한 문장 데이터를 준비한다. positive_texts에는 “정말 좋다”, “책임감 있게 행동했다”처럼 긍정적인 문장을 저장하고, negative_texts에는 “정말 싫다”, “맡은 일을 못했다”처럼 부정적인 문장을 저장한다.

texts에는 긍정 문장과 부정 문장을 하나로 합쳐 저장한다. labels에는 각 문장의 정답을 저장하며, 긍정 문장은 1, 부정 문장은 0으로 표시한다. len()과 count()를 사용해 전체 문장 수와 긍정·부정 문장 수를 확인한다. 이 데이터는 이후 모델이 문장의 긍정과 부정을 구분하도록 학습하는 데 사용한다.

(3) 텍스트 잔처리

# 셀 3. 텍스트 전처리

def clean_text(text):
  text = re.sub(r"[^가-힣\s]","",text)
  return text

clean_texts = [clean_text(text) for text in texts]

for before, after in zip(texts,clean_texts):
  print(before,"->",after)

셀 3에서는 모델이 문장을 쉽게 학습할 수 있도록 텍스트를 전처리한다. clean_text() 함수는 정규표현식 [^가-힣\s]을 사용해 한글과 공백을 제외한 숫자, 영문, 특수문자 등을 제거한다.

이 함수를 texts의 모든 문장에 적용하고, 전처리된 결과를 clean_texts에 저장한다. 마지막으로 zip()을 사용해 전처리 전 문장과 전처리 후 문장을 함께 출력하여 어떻게 달라졌는지 확인한다.

(4) TF-IDF 변환

# 셀 4. TF-IDF 변환

vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(clean_texts)

print("단어 목록:")
print(vectorizer.get_feature_names_out())

df = pd.DataFrame(
    X.toarray(),
    columns=vectorizer.get_feature_names_out()
)
df

셀 4에서는 전처리된 문장을 TF-IDF 방식의 숫자 벡터로 변환한다. TfidfVectorizer()로 변환기를 만들고, fit_transform()을 사용해 clean_texts에 등장하는 단어를 학습한 뒤 각 문장을 숫자로 변환한다. 변환된 결과는 X에 저장한다.

get_feature_names_out()은 모델이 학습한 전체 단어 목록을 출력한다. X.toarray()는 TF-IDF 결과를 배열 형태로 바꾸고, pd.DataFrame()은 이를 표 형태로 정리한다. 표의 행은 각 문장을 나타내고, 열은 단어를 나타낸다. 각 칸의 숫자는 해당 문장에서 그 단어가 가지는 중요도를 의미하며, 값이 클수록 중요한 단어라고 볼 수 있다.

(5) 모델 학습

# 셀 5. 모델 학습

model = LogisticRegression()
model.fit(X,labels)

print("모델 학습 완료!")

셀 5에서는 로지스틱 회귀 모델을 사용해 문장을 분류하는 방법을 학습한다. 먼저 LogisticRegression()으로 분류 모델을 만들고 model에 저장한다.

model.fit(X, labels)는 TF-IDF로 변환된 문장 데이터 X와 각 문장의 정답인 labels를 이용해 모델을 학습한다. 모델은 단어의 중요도와 긍정·부정의 관계를 학습하며, 새로운 문장이 입력되었을 때 긍정인지 부정인지 예측할 수 있게 된다. 학습이 끝나면 “모델 학습 완료!”라는 문장을 출력한다.

(6) 새로운 문장 테스트

# 셀 6 새로운 문장 직접 테스트

while True:
  sentence = input("문장 입력 (종료:q)")

  if sentence.lower() == "q":
    print("테스트를 종료합니다.")
    break

  cleaned = clean_text(sentence)
  new_X = vectorizer.transform([cleaned])

  result = model.predict(new_X)[0]
  probability = model.predict_proba(new_X)[0]

  print("예측 결과:","긍정" if result == 1 else "부정")
  print("긍정 확률:",round(probability[1] * 100,2),"%")
  print("부정 확률:",round(probability[0] * 100,2),"%")
  print("-" * 30)

셀 6에서는 사용자가 새로운 문장을 직접 입력해 모델의 예측 결과를 확인한다. while True를 사용해 문장을 반복해서 입력받으며, 사용자가 q를 입력하면 반복문을 종료한다. sentence.lower()를 사용하므로 대문자 Q를 입력해도 종료된다.

입력된 문장은 clean_text()로 전처리한 뒤, vectorizer.transform()을 사용해 학습할 때와 같은 TF-IDF 벡터로 변환한다. model.predict()는 문장이 긍정인지 부정인지 예측하고, model.predict_proba()는 긍정과 부정일 확률을 계산한다.

예측값이 1이면 “긍정”, 0이면 “부정”을 출력한다. 각 확률은 100을 곱해 백분율로 바꾸고 round()를 사용해 소수점 둘째 자리까지 표시한다. 이후 구분선을 출력하고 다음 문장을 입력받는다.

Tistory 원문 보기 · 머신러닝 3차시, 자연어 처리

머신러닝 3차시 Colab 실습 열기

IRIS - Machine Learning Study · 2차시

Sun, 20 Sep 2026 00:00:00 GMT

1. 회귀란?

데이터 사이의 관계를 찾아 새로운 데이터의 값을 예측하는 머신러닝 방법이다.

기존 데이터를 학습하여 입력값과 결과값 사이에 어떤 관계가 있는지 찾고, 그 관계를 이용해 새로운 데이터의 결과값을 예측한다.

예) 공부 시간을 이용해 시험 점수 예측, 집의 크기를 이용해 집값 예측.

2. 독립변수, 종족변수

예측에 사용하는 값을 독립변수, 예측하려는 결과값을 종속변수라고 한다. 독립변수는 결과에 영향을 줄 수 있는 입력 데이터이고, 종속변수는 독립변수와의 관계를 바탕으로 예측하는 값이다.

예) 집값을 예측하는 경우

독립변수: 집의 크기, 방의 개수, 위치, 건축 연도 등
종속변수: 집값

즉, 여러 독립변수의 정보를 이용해 종속변수가 어떤 값이 될지 예측한다.

3. 과대 적합과 과소 적합

과대적합과 과소적합은 머신러닝 모델이 학습 데이터를 얼마나 잘 학습했는지를 나타내는 개념이다.

과대적합(Overfitting): 모델이 학습 데이터를 너무 자세하게 학습하여 학습 데이터에서는 성능이 좋지만 새로운 데이터에서는 성능이 떨어지는 현상이다. 데이터의 전체적인 특징뿐만 아니라 불필요한 부분이나 잡음까지 학습한 경우임
과소적합(Underfitting): 모델이 데이터를 충분히 학습하지 못하여 학습 데이터와 새로운 데이터 모두에서 성능이 낮은 현상이다. 즉, 데이터의 중요한 특징이나 관계를 제대로 찾지 못한 경우임

예를 들어 과대적합은 기출문제의 답만 외워서 비슷한 문제만 풀 수 있는 상태, 과소적합은 기본 개념조차 충분히 이해하지 못한 상태라고 볼 수 있다.

4. 단순 선형 회기

하나의 독립변수를 이용하여 하나의 종속변수를 예측하는 회귀 방법이다. 입력값과 결과값 사이의 관계를 하나의 직선으로 나타내어 새로운 값을 예측한다.

(1) 장점

구조가 단순하여 이해하고 해석하기 쉽다.
계산이 빠르고 결과를 직관적으로 확인할 수 있다.

(2) 단점

모든 데이터의 관계가 직선으로 나타나는 것은 아니기 때문에 현실의 복잡한 관계를 표현하기 어렵다. → 한계가 많다.
이상치가 있으면 예측 결과에 큰 영향을 받을 수 있다.

(3) 실습

단순 선형 회귀 Colab 실습

(1) 데이터 불러오기

import matplotlib.pyplot as plt
from sklearn.datasets import load_diabetes
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error

# 데이터 불러오기
diabetes = load_diabetes()

단순 선형 회귀 실습을 위해 필요한 라이브러리와 당뇨병 데이터셋을 불러오는 역할을 한다.

matplotlib을 사용해 데이터를 그래프로 시각화할 수 있도록 하고, sklearn에서 제공하는 당뇨병 데이터셋을 불러 올 수 있다.

데이터를 학습용과 테스트용으로 나누기 위한 train_test_split과 선형 회귀 모델을 만들기 위한 LinearRegression을 불러온다.

마지막으로 평균 제곱 오차, 결정계수, 평균 절대 오차를 이용해 모델의 예측 성능을 평가할 수 있도록한다.

(2) BMI 데이터와 결과 값 설정 및 데이터 정보 확인

#BMI 데이터와 결과 값 설정
X = diabetes.data[:, [2]]
y = diabetes.target

#데이터 정보 확인
print("데이터 크기 :",X.shape)
print("데이터 개수 :",len(X))

당뇨병 데이터에서 BMI에 해당하는 값만 독립변수 X로 설정하고, 질병 진행 정도를 종속변수 y로 설정한다. 이후 X의 shape와 len을 출력하여 데이터가 몇 개의 행과 열로 구성되어 있는지, 전체 데이터의 개수가 몇 개인지 확인한다.

(3) 데이터 분리와 학습

#학습 데이터와 테스트 데이터 분리
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,
    random_state=42
)

# 선형 회기 모델 생성
model = LinearRegression()

# 모델 학습
model.fit(X_train, y_train)

# 결과 예측
prediction = model.predict(X_test)

#예측 결과 확인
print("========예측 결과========")

for i in range(10):
  print("실제 ",y_test[i],"/ 예측:",round(prediction[i],1))

전체 데이터를 학습용 데이터와 테스트용 데이터로 나누고, 테스트 데이터는 전체의 20%가 되도록 설정한다. 이후 LinearRegression을 이용해 선형 회귀 모델을 생성하고, 학습 데이터를 사용하여 BMI와 질병 진행 정도 사이의 관계를 학습시킨다. 학습이 끝난 모델에 테스트 데이터를 입력하여 결과값을 예측하고, 실제 값과 예측 값을 비교할 수 있도록 처음 10개의 결과를 출력한다.

(4) 모델 성능 평가 및 결과 확인

#모델 성능 평가
mae = mean_absolute_error(y_test, prediction)
r2 = r2_score(y_test, prediction)

print("평균 절대 오차 MAE:", round(mae,2))
print("R^2 점수:", round(r2,2))

#회귀선 그리기
X_sorted = sorted(X_test[:,0])
y_sorted = model.predict([[x] for x in X_sorted])

plt.scatter(X_test,y_test)
plt.plot(X_sorted,y_sorted)

plt.xlabel("BMI")
plt.ylabel("Disease Progression")
plt.title("Simple Lonear Regression")

plt.show()

학습한 선형 회귀 모델의 성능을 확인하기 위해 평균 절대 오차(MAE)와 결정계수(R²)를 계산한다. MAE는 실제 값과 예측 값의 차이가 평균적으로 얼마나 나는지를 나타내며, 값이 작을수록 예측 오차가 적다는 의미이다. R²는 모델이 데이터의 변화를 얼마나 잘 설명하는지를 나타내는 지표이다. 이후 테스트 데이터의 BMI 값을 순서대로 정렬하고 모델의 예측값을 구해 회귀선을 만든다. 실제 데이터는 산점도로 표시하고 예측 결과는 직선으로 나타내어 BMI와 질병 진행 정도 사이의 관계를 시각적으로 확인한다.

5. 다중 선형 회귀

여러 개의 독립변수를 이용하여 하나의 종속변수를 예측하는 회귀 방법이다. 각각의 독립변수가 결과값에 어떤 영향을 주는지 함께 분석하여 예측한다.

(1) 장점

여러 요인을 동시에 고려하여 결과값을 예측할 수 있다.
단순 선형 회귀보다 현실의 복잡한 문제를 표현하기에 적합하다.

(2) 단점

독립변수들 사이의 상관관계가 너무 높으면 모델의 정확도와 해석력이 떨어질 수 있다.
사용하는 변수가 많아질수록 모델이 복잡해지고 불필요한 변수가 포함될 가능성이 있다.

6. 다항 회귀

데이터 사이의 관계를 직선이 아닌 곡선 형태로 표현하여 결과값을 예측하는 회귀 방법이다. 독립변수를 제곱, 세제곱 등의 형태로 변환하여 복잡한 비선형 관계를 학습한다.

(1) 장점

직선으로 표현하기 어려운 비선형 관계를 설명할 수 있다.
데이터의 변화가 곡선 형태일 때 더 적절한 예측이 가능하다.

(2) 단점

차수가 너무 높아지면 학습 데이터에 지나치게 맞춰지는 과대적합이 발생할 수 있다.
차수가 높아질수록 모델이 복잡해져 결과를 해석하기 어려워질 수 있다.

7. 비선형 회귀

입력값과 결과값의 관계가 직선 형태로 표현되지 않을 때 사용하는 회귀 방법이다. 데이터의 관계를 곡선이나 특정 함수 형태로 표현하여 복잡한 변화를 예측한다.

(1) 장점

선형 회귀로 설명하기 어려운 복잡한 관계까지 표현할 수 있다.
데이터의 실제 변화 형태에 더 잘 맞는 모델을 만들 수 있다.

(2) 단점

데이터의 관계에 맞는 함수 형태를 미리 가정해야 하는 경우가 많다.
함수 형태를 잘못 선택하면 예측 성능이 크게 떨어질 수 있다.

8. 선형 데이터와 비선형 데이터

(1) 선형 데이터

입력값이 변할 때 결과값도 일정한 방향과 비율에 가깝게 변하여 하나의 직선으로 표현할 수 있는 데이터이다. 입력값이 증가하거나 감소함에 따라 결과값도 일정한 형태로 변화한다.

예시

1차 함수
공부 시간이 늘어날수록 점수가 일정하게 증가하는 경우

(2) 비선형 데이터

입력값이 변할 때 결과값의 변화가 일정하지 않아 하나의 직선으로 표현하기 어려운 데이터이다. 주로 곡선 형태의 관계를 나타낸다.

예시

2차 함수
지수 함수
로그 함수

9. 규제를 사용하는 회귀

회귀 모델이 학습 데이터에 지나치게 맞춰지도록 너무 복잡하게 만들어지면 과적합이 발생할 수 있다.

이를 방지하기 위해 모델의 복잡도를 제한하고, 특정 변수의 영향이 지나치게 커지지 않도록 조절하는 방법을 규제라고 한다.

목적

과적합을 줄여 새로운 데이터에서도 좋은 성능을 내도록 한다.
모델이 지나치게 복잡해지는 것을 방지한다.
특정 독립변수에 지나치게 의존하는 것을 줄인다.

10. 릿지 회귀

특정 독립변수의 영향력이 지나치게 커지는 것을 막고, 여러 변수를 비교적 안정적으로 사용하도록 만드는 회귀 방법이다. 각 변수의 계수가 너무 커지지 않도록 규제를 적용하여 모델의 복잡도를 줄인다.

(1) 장점

과적합을 줄이는 데 효과적이다.
여러 변수를 안정적으로 사용할 수 있어 예측 성능이 비교적 안정적이다.

(2) 단점

중요하지 않은 변수의 계수를 줄일 수는 있지만 완전히 0으로 만들지는 않기 때문에, 불필요한 변수가 모델에 남아 있을 수 있다.

(3) 실습

릿지 회귀 Colab 실습

(1) 데이터 불러오기 및 입력값 설정

import matplotlib.pyplot as plt
from sklearn.datasets import load_diabetes
from sklearn.model_selection import train_test_split
from sklearn.linear_model import Ridge
from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error

# 데이터 불러오기
diabetes = load_diabetes()

# 입력값과 결과값 설정
X = diabetes.data
y = diabetes.target

릿지 회귀 실습에 필요한 라이브러리와 당뇨병 데이터셋을 불러온다. 이후 diabetes.data에 저장된 여러 특성값을 독립변수 X로 설정하고, 당뇨병의 질병 진행 정도를 종속변수 y로 설정한다.

(2) 데이터 분리 및 릿지 회귀 모델 학습

# 데이터 정보 확인
print("데이터 크기 :", X.shape)
print("특성 이름 :", diabetes.feature_names)

# 학습 데이터와 테스트 데이터 분리
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,
    random_state=42
)

# 릿지 회귀 모델 생성
model = Ridge(alpha=1.0)

# 모델 학습
model.fit(X_train, y_train)

# 결과 예측
prediction = model.predict(X_test)

# 예측 결과 확인
print("\n===== 예측 결과 =====")

for i in range(10):
    print(
        "실제 :", y_test[i],
        "/ 예측 :", round(prediction[i], 1)
    )

# 모델 성능 평가
mae = mean_absolute_error(y_test, prediction)
r2 = r2_score(y_test, prediction)

print("\n평균 절대 오차(MAE) :", round(mae, 2))
print("R² 점수 :", round(r2, 2))

데이터의 크기와 특성 이름을 확인한 뒤, 전체 데이터를 학습용 데이터와 테스트용 데이터로 나눈다. 테스트 데이터는 전체의 20%로 설정한다. 이후 alpha=1.0으로 릿지 회귀 모델을 생성하고 학습 데이터를 이용해 모델을 학습시킨다. 학습이 끝난 모델로 테스트 데이터의 결과값을 예측한 뒤 실제 값과 예측 값을 비교한다. 마지막으로 MAE와 R² 점수를 계산하여 모델의 예측 오차와 성능을 확인한다.

(3) 특성별 계수 확인 및 규제 강도 비교

import matplotlib.pyplot as plt

# 특성별 계수 확인
print("====== 특성별 계수 ======")
for name,coef in zip(diabetes.feature_names,model.coef_):
    print(name,":",round(coef,2))

# 규제 강도별 성능 비교
alpha_list = [0.01,0.1,1,10,100]
scores = []

for alpha in alpha_list:
    test_model = Ridge(alpha=alpha)
    test_model.fit(X_train,y_train)
    test_prediction = test_model.predict(X_test)

    test_score = r2_score(y_test,test_prediction)
    scores.append(test_score)

    print("alpha =",alpha,"/ R²=",round(test_score,3))

# 규제 강도별 성능 그래프
plt.plot(range(len(alpha_list)),scores,marker='o')
plt.xticks(range(len(alpha_list)),alpha_list)

plt.xlabel("Alpha")
plt.ylabel("R2 Score")
plt.title("Ridge Regression")

plt.show()

학습된 릿지 회귀 모델에서 각 특성이 결과값에 얼마나 영향을 주는지 계수를 확인한다. 이후 alpha 값을 0.01, 0.1, 1, 10, 100으로 바꾸어가며 여러 개의 릿지 회귀 모델을 학습시키고, 각 모델의 R² 점수를 계산하여 규제 강도에 따른 성능 차이를 비교한다. 마지막으로 alpha 값과 R² 점수를 그래프로 나타내어 어떤 규제 강도에서 모델의 성능이 좋은지 확인한다.

11. 라쏘 회귀

중요도가 낮은 독립변수의 계수를 0으로 만들어 불필요한 변수를 제거하는 회귀 방법이다. 규제를 통해 모델을 단순하게 만들고, 예측에 중요한 변수만 남도록 한다.

(1) 장점

불필요한 변수를 자동으로 제거할 수 있다.
중요한 변수만 남기 때문에 모델의 해석력이 높아진다.
과적합을 줄이는 데 도움이 된다.

(2) 단점

변수가 많고 서로 강한 상관관계를 가지고 있으면 어떤 변수를 남길지 불안정해질 수 있다.
중요한 변수까지 제거될 가능성이 있다.

12. 엘라슽틱넷 회귀

릿지 회귀와 라쏘 회귀의 특징을 함께 사용하는 회귀 방법이다. 변수의 영향력이 지나치게 커지는 것을 줄이는 동시에, 중요하지 않은 변수의 계수를 0으로 만들어 불필요한 변수를 제거할 수 있다.

(1) 장점

릿지와 라쏘의 장점을 함께 활용할 수 있다.
과적합을 줄이면서 불필요한 변수도 제거할 수 있다.
변수들이 서로 강하게 연관되어 있을 때도 비교적 안정적으로 사용할 수 있다.

(2) 단점

릿지와 라쏘의 규제 비율을 함께 조절해야 하므로 설정이 복잡하다.
적절한 규제 강도와 비율을 찾는 과정이 필요하다.

13. 로지스틱 회귀

이름에는 회귀가 들어가 있지만 주로 분류 문제에 사용하는 머신러닝 알고리즘이다. 입력 데이터를 바탕으로 데이터가 특정 종류에 속할 확률을 계산한 뒤, 그 확률을 기준으로 분류 결과를 결정한다.

(1) 장점

계산 속도가 빠르고 구조가 단순하다.
각 변수의 영향력을 비교적 쉽게 해석할 수 있다.
이진 분류 문제에서 효과적으로 사용할 수 있다.

(2) 단점

복잡한 비선형 관계를 가진 데이터를 잘 표현하지 못한다.
데이터의 관계가 복잡할수록 분류 성능이 떨어질 수 있다.

Tistory 원문 보기 · 머신러닝 2차시, 회귀

IRIS - Machine Learning Study · 1차시

Tue, 15 Sep 2026 00:00:00 GMT

1. 머신 러닝이란?

머신러닝은 컴퓨터가 데이터를 바탕으로 규칙과 특징을 스스로 학습하고, 학습한 내용을 활용해 새로운 데이터의 결과를 예측하거나 판단하는 기술이다.

2. 머신 러닝의 차이점

(1) 전통적인 프로그래밍

전통적인 프로그래밍은 사람이 규칙을 직접 만들고, 컴퓨터는 그 규칙에 따라 결과를 출력하는 방식이다.

(2) 머신러닝

머신러닝은 데이터와 정답을 컴퓨터에 제공하면, 컴퓨터가 그 안에서 규칙을 스스로 찾아 새로운 결과를 예측하는 방식이다.

전통적인 프로그래밍은 사람이 규칙을 직접 작성해야 하지만, 머신러닝은 컴퓨터가 데이터를 통해 규칙을 학습한다는 차이가 있다.

3. 머신 러닝의 사례

알고리즘

스팸 메일 분류

얼굴 인식

상품 추천

음성 인식

4. 데이터란?

데이터는 관찰, 측정, 조사 등을 통해 얻은 숫자, 문자, 이미지 등의 자료로, 분석하거나 학습하는 데 사용되는 정보이다.

5. 데이터의 종류

학습 데이터: 머신러닝 모델을 학습시키기 위해 사용하는 데이터이다. 데이터의 특징과 정답을 함께 제공하여, 컴퓨터가 규칙을 찾도록 한다.
테스트 데이터: 학습이 끝난 모델의 성능을 확인하기 위해 사용하는 데이터이다. 학습에 사용하지 않은 데이터를 이용해 모델이 얼마나 정확하게 예측하는지 평가한다.

6. 머신 러닝의 학습 과정

데이터 수집: 머신러닝에 사용할 데이터를 모은다.
데이터 점검 및 탐색: 데이터의 형태, 분포, 오류, 결측값 등을 확인한다.
데이터 전처리 및 정제: 학습에 방해되는 데이터를 정리하고 필요한 형태로 변환한다.
테스트 데이터 분리: 전체 데이터 중 일부를 테스트용으로 따로 나눈다.
모델링 및 훈련: 데이터를 이용해 머신러닝 모델을 학습시킨다.
평가: 테스트 데이터를 이용해 모델의 성능을 확인한다.
모델 개선: 성능이 부족하면 데이터나 모델을 수정해 다시 학습한다.
배포: 완성된 모델을 실제 서비스에 적용한다.
재수집 및 개선: 새로운 데이터를 수집해 모델을 지속적으로 개선한다.

7. 머신러닝의 종류

지도 학습

정답이 있는 데이터를 이용해 학습하는 방법이다. 입력 데이터와 그에 대한 정답을 함께 제공하여, 새로운 데이터가 들어왔을 때 결과를 예측하도록 한다.

예시: 스팸 메일 분류, 집값 예측, 이미지 분류

비지도 학습

정답이 없는 데이터를 이용해 데이터의 구조나 특징을 찾는 방법이다. 비슷한 데이터를 그룹으로 묶거나, 데이터의 숨겨진 패턴을 발견하는 데 사용된다.

예시: 고객 유형 분류, 추천 시스템, 이상치 탐지

강화 학습

행동에 대한 보상을 통해 학습하는 방법이다. 컴퓨터가 여러 행동을 시도하면서 좋은 결과를 얻는 행동을 학습한다.

예시: 게임 AI, 자율주행 자동차, 로봇 제어

8. 머신 러닝의 장단점

장점

많은 데이터를 빠르게 분석할 수 있다.
사람이 직접 규칙을 만들지 않아도 된다.
사람이 찾기 어려운 패턴을 발견할 수 있다.

단점

많은 데이터가 필요하다.
데이터가 좋지 않으면 결과도 좋지 않다.

9. 실습

(1) 필요한 도구 불러오기

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

scikit-learn은 파이썬에서 머신러닝을 쉽게 사용할 수 있도록 도와주는 라이브러리다. 여기서는 붓꽃 데이터를 불러오고, 학습용·테스트용 데이터를 나누며, 의사결정 트리 모델의 정확도를 확인한다.

(2) 붓꽃 데이터 불러오기

# 1. 붓꽃 데이터 불러오기
iris = load_iris()

# x는 꽃의 특징 데이터
# 꽃받침 길이, 꽃받침 너비, 꽃잎 길이, 꽃잎 너비가 들어있음
X = iris.data

# y는 꽃의 정답 데이터
# 0 = setosa
# 1 = versicolor
# 2 = virginica
y = iris.target

X에는 꽃받침 길이·너비와 꽃잎 길이·너비가, y에는 꽃의 종류 정답이 들어 있다. 값 0, 1, 2는 각각 setosa, versicolor, virginica를 의미한다.

(3) 학습 데이터와 테스트 데이터로 나누기

# 2. 학습 데이터와 테스트 데이터로 나누기
# 전체 데이터의 80%는 학습용, 20%는 확인용
X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,
    random_state=42
)

전체 데이터의 80%는 학습에 사용하고, 나머지 20%는 학습이 끝난 뒤 성능을 확인하는 데 사용한다. random_state=42를 지정하면 실행할 때마다 같은 방식으로 데이터가 나뉜다.

(4) 머신러닝 모델 만들기

# 3. 머신러닝 모델 만들기
# 의사결정 트리 모델 사용
model = DecisionTreeClassifier(random_state=42)

의사결정 트리는 질문을 여러 번 나누며 데이터를 분류하는 머신러닝 모델이다.

(5) 머신러닝 학습시키기

# 4. 머신러닝 학습시키기
# 학습 데이터를 이용하여 꽃의 특징을 학습
model.fit(X_train, y_train)

fit()은 학습 데이터의 특징과 정답을 이용해 모델이 분류 규칙을 찾도록 하는 함수다.

(6) 테스트 데이터로 꽃 종류 예측하기

# 5. 테스트 데이터로 꽃 종류 예측하기
prediction = model.predict(X_test)

학습에 사용하지 않은 테스트 데이터의 꽃 종류를 예측한다.

(7) 실제 정답과 예측 결과 출력

# 6. 실제 정답과 머신러닝의 예측 결과 출력
print("[머신러닝 예측 결과]")
print(prediction)

[머신러닝 예측 결과]
[1 0 2 1 1 0 1 2 1 1 2 0 0 0 0 1 2 1 1 2 0 2 0 2 2 2 2 2 0 0]

배열의 각 숫자는 테스트 데이터에 대한 모델의 예측 결과다.

(8) 정확도 계산하기

# 7. 정확도 계산하기
accuracy = accuracy_score(y_test, prediction)
print("")
print("정확도:", accuracy * 100, "%")

정확도: 100.0 %

accuracy_score()는 실제 정답과 예측 결과가 일치하는 비율을 계산한다.

(9) 새로운 꽃 데이터 입력하기

# 8. 새로운 꽃 데이터 입력하기
# 순서: 꽃받침 길이, 너비, 꽃잎 길이, 너비
new_flower = [[5.1, 3.5, 1.4, 0.2]]

새 꽃의 특징을 입력한다. 값의 순서는 꽃받침 길이, 꽃받침 너비, 꽃잎 길이, 꽃잎 너비다.

(10) 새로운 꽃 종류 예측하기

# 9. 새로운 꽃 종류 예측하기
result = model.predict(new_flower)

학습한 모델이 새로운 꽃의 종류를 예측한다.

(11) 예측 결과 출력하기

# 10. 예측 결과 출력하기
print()
print("[새로운 꽃 예측 결과]")
print("꽃 번호:", result[0])
print("꽃 종류:", iris.target_names[result[0]])

[새로운 꽃 예측 결과]
꽃 번호: 0
꽃 종류: setosa

입력한 특징을 바탕으로 모델은 이 꽃을 setosa로 예측했다.

(12) Colab

Google Colab 실습 노트북 열기

10. 머신 러닝 모델 조사하기

인공신경망 (Artificial Neural Network, ANN)

인공신경망은 사람의 뇌에 있는 신경세포의 연결 구조를 본떠 만든 머신러닝 모델이다. 여러 개의 인공 뉴런이 서로 연결되어 데이터를 입력받고, 반복적인 학습을 통해 데이터의 특징과 규칙을 찾아낸다.

인공신경망은 보통 입력층, 은닉층, 출력층으로 구성된다.

입력층: 데이터를 처음 입력받는 부분이다. 예를 들어 이미지의 픽셀 값이나 센서 데이터가 들어간다.
은닉층: 입력된 데이터를 여러 단계로 처리하면서 특징을 학습하는 부분이다. 은닉층이 많아질수록 복잡한 패턴을 학습할 수 있다.
출력층: 최종 결과를 출력하는 부분이다. 예를 들어 이미지가 고양이인지 개인지, 숫자가 무엇인지 등을 판단한다.

인공신경망은 이미지 인식, 음성 인식, 자연어 처리 등 복잡한 데이터를 다루는 분야에서 많이 사용된다. 장점은 복잡한 패턴을 학습할 수 있다는 것이고, 단점은 많은 데이터와 학습 시간이 필요하며 모델의 내부 동작을 이해하기 어려울 수 있다는 점이다.

Tistory 원문 보기 · 머신 러닝 1차시

JBU CTF

Tue, 01 Sep 2026 00:00:00 GMT

JBU-CTF 소감

JBU-CTF에 참여하면서 웹, 포너블, 리버싱, 포렌식, 스테가노그래피 등 다양한 분야의 문제를 직접 풀이했습니다. 처음에는 문제마다 요구하는 지식과 접근 방식이 달라 막막하게 느껴졌지만, 하나씩 파일 구조와 실행 흐름을 분석하고 가설을 세워 검증하는 과정을 반복하면서 문제를 바라보는 시야가 넓어졌습니다.

웹 문제

웹 문제에서는 단순히 웹페이지의 기능을 사용하는 것을 넘어, 클라이언트 JavaScript와 API 요청을 분석하는 데 집중했습니다. i hate pickle 문제에서는 처음에는 이름처럼 pickle 역직렬화 취약점이 핵심이라고 생각했지만, 실제로는 서버 기술 스택과 OpenAPI 문서에 노출된 내부 라우트를 확인하는 것이 더 직접적인 해결 방법이었습니다.

처음 떠올린 공격 기법에만 집중하기보다, 서버가 제공하는 정보와 전체적인 공격 표면을 먼저 살펴보는 습관을 기를 수 있었습니다.

또한 SCP 게시판 문제에서는 JWT의 알고리즘 혼동 취약점과 FreeMarker SSTI를 단계적으로 이용했습니다. 공개된 JWK를 바탕으로 권한을 위조하고, 이후 게시글 미리보기 기능에서 템플릿이 실행되는 과정을 확인하면서 각각의 취약점이 독립적으로 존재하는 것이 아니라 하나의 공격 흐름으로 연결될 수 있다는 점을 배웠습니다. 프론트엔드에서 접근을 막고 있더라도 서버에서 권한 검증이 제대로 이루어지는지 확인해야 한다는 점도 직접 체감했습니다.

포너블

포너블 문제를 풀이하면서는 메모리 구조와 바이너리 보호 기법에 대한 이해를 많이 넓혔습니다. Line 2, SCP-804 문제에서는 스택 버퍼 오버플로를 기반으로 주소를 leak하고, stack pivot과 ROP 체인을 구성해 최종적으로 셸을 얻는 과정을 경험했습니다. JBUMON에서는 save/load 과정의 상태 관리 오류를 이용해 숨겨진 스킬을 활성화한 뒤, 정보 유출과 ret2libc를 연결했습니다.

피노키오 문제에서는 커스텀 allocator의 잘못된 coalesce 로직으로 인해 가짜 청크를 만들고 callback 포인터를 덮는 과정을 분석했습니다.

big chunk manager

big chunk manager 문제는 특히 기억에 남습니다. 단순한 힙 문제라고 생각했지만, mmap으로 할당되는 큰 청크들의 배치와 헤더 변조, tcache poisoning, GOT overwrite, format string leak을 차례대로 연결해야 했습니다.

이 문제를 해결하며 취약점 하나만 이해하는 것보다, 메모리 상태가 각 단계에서 어떻게 변화하는지 추적하고 전체 익스플로잇 흐름을 설계하는 능력이 중요하다는 것을 느꼈습니다.

원격 환경에서는 입력 방식과 libc 버전 차이로 인해 로컬에서 동작하던 코드가 실패하기도 했고, 이를 수정하는 과정에서 실제 환경을 고려한 검증과 디버깅의 중요성도 배웠습니다.

포렌식과 리버싱

포렌식과 리버싱 문제에서는 여러 형태의 단서를 조합하는 경험을 했습니다. 선물 문제에서는 APK를 디컴파일해 암호화와 데이터 추출 로직을 파악하고, 사진의 EXIF 정보, PNG의 LSB 데이터, WAV와 MP4에 숨겨진 FSK 신호를 각각 분석했습니다.

각각의 조각을 올바른 순서로 조합한 뒤 PBKDF2와 AES-GCM 복호화를 수행해야 했기 때문에, 단일 도구에 의존하기보다 파일 형식과 애플리케이션의 동작 원리를 함께 이해해야 했습니다. 이 과정에서 겉으로 보이는 문자열이 항상 정답은 아니며, 문제에 포함된 미끼와 실제 단서를 구분하는 분석력이 필요하다는 점을 배웠습니다.

이번 대회를 통해 배운 점

이번 CTF를 통해 가장 크게 성장한 부분은 문제를 대하는 방식입니다. 이전에는 정답에 빠르게 도달하는 것에 집중했다면, 이제는 먼저 주어진 파일과 서비스의 구조를 정리하고, 가능한 공격 지점을 좁힌 뒤, 각 가설을 작은 스크립트와 실험으로 검증하려고 합니다.

풀이 과정에서 작성한 분석 코드와 write-up을 정리하면서, 문제를 해결하는 능력뿐만 아니라 내가 어떤 근거로 결론에 도달했는지를 설명하는 능력도 중요하다는 것을 알게 되었습니다.

JBU-CTF는 다양한 보안 기술을 직접 적용해 보고, 부족한 부분을 구체적으로 확인할 수 있었던 경험이었습니다.

앞으로도 바이너리와 운영체제의 동작 원리, 웹 애플리케이션의 인증 및 템플릿 보안, 파일 포맷과 암호화 구조를 꾸준히 공부하며 단순히 문제를 푸는 사람을 넘어 취약점의 원인과 안전한 대응 방법까지 설명할 수 있는 보안 인재로 성장하고 싶습니다.

Study Flow – Weekly Timetable Planner

Sun, 23 Aug 2026 00:00:00 GMT

Study Flow – Weekly Timetable Planner

역할: Developer
분야: Web Application / Productivity
사용 기술: React, TypeScript, LocalStorage, CSS

공부 일정을 시간표 형태로 직접 관리할 수 있는 웹사이트 Study Flow를 만들었다. 단순히 일정 목록을 적는 방식이 아니라, 한 주의 시간을 한눈에 보면서 공부 계획을 세우고 과목별 학습 시간을 확인할 수 있도록 구성했다.

목표: 공부 계획을 직접 채우고 수정하면서, 과목별로 얼마나 시간을 사용했는지 바로 확인할 수 있는 개인용 주간 플래너 만들기

주간 시간표

월요일부터 일요일까지의 일정을 시간 단위 그리드로 표시했다. 일정 블록은 시작 시간과 종료 시간을 기준으로 자동 배치되며, 자정을 넘는 일정도 다음 날로 이어서 보이도록 처리했다.

각 일정에는 과목, 학습 내용, 시간 정보가 함께 표시된다. 블록을 누르면 상세 내용을 확인할 수 있고, 기존 일정을 수정·복사·삭제할 수 있도록 만들었다.

일정 관리 기능

새 일정을 추가할 때 요일, 과목, 학습 내용, 시작 시간, 종료 시간을 선택할 수 있다. 기본 과목 외에도 직접 과목명을 입력할 수 있게 했고, 과목마다 색상을 다르게 표시해서 시간표를 빠르게 구분할 수 있도록 했다.

작성한 일정은 브라우저의 LocalStorage에 저장된다. 그래서 새로고침하거나 다시 접속해도 같은 브라우저에서는 계획이 유지된다.

과목별 학습 시간 분석

시간표 아래에는 과목별로 공부한 시간을 막대그래프로 보여주는 영역을 넣었다. 등록된 일정의 시간을 자동으로 합산해서 과목별 학습 시간과 비율을 확인할 수 있다.

계획을 작성하는 기능에서 끝나지 않고, 내가 어느 과목에 시간을 더 많이 쓰고 있는지 확인하는 기능까지 연결하는 것이 핵심이었다.

앞으로 개선하고 싶은 점

현재는 개인 브라우저에 저장되는 방식이지만, 이후에는 계정 기능이나 클라우드 저장 기능을 추가해서 다른 기기에서도 같은 시간표를 불러올 수 있게 만들고 싶다. 또한 주간 목표 달성률, 일정 알림, 월간 통계 기능도 추가해보고 싶다.

IRIS - Computer Vision Study · 2차시

Sun, 02 Aug 2026 00:00:00 GMT

1. 사용 라이브러리

OpenCV (cv2) 이미지를 읽고, 자르고, 크기 조절 및 보정하는 등 이미지 처리와 조작에 사용

Matplotlib (plt) 처리한 이미지를 화면에 출력하고 데이터를 시각적으로 표현하는 데 사용

2. 이미지 불러오기

!wget -O image.jpg 이미지 링크

원하는 이미지를 불러올 수 있습니다.

(1) 이미지 출력 준비

plt.imread()

(2) 이미지 출력

plt.imshow()

3. 이미지에 효과 적용하기

(1) 흑백

gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

아까 불러온 이미지에 흑백 처리를 할 수 있습니다.

(2) 블러

blurred = cv2.GaussianBlur(gray, (필터, 크기), 0) // 0 부분은 표준 편차인데 0으로 설정하면 자동으로 설정해준다.

사진이 흐려진 것을 확인할 수 있다.

(3) 엣지 따기

edges = cv2.Canny(gray, 상한값,하한값)

이런 식으로 선이 따지는 것을 볼 수 있다.

(4) 이미지 크기 재설정

resized = cv2.resize(image, (크기, 크기)) // 가로 , 세로

이미지의 크기를 바꿀 수 있는 것을 확인할 수 있다.

(5) 색 반전

inverted = 255 - image //(픽셀 최대값) - (현재값)

이렇게 사진의 색이 반전되는 것을 볼 수 있다.

(6) 좌우 반전

flipped = np.fliplr(image)

이미지가 좌우 반전 된 것을 확인할 수 있다.

(7) 이미지 밝게 만들기

brighter = np.clip(image * 밝기값, 0, 255).astype(np.uint8)

곱해지는 밝기 값이 핵심이다.

이미지가 밝아진 것을 확인 할 수 있다.

(8) 모자이크 처리하기

h, w = image.shape[:2]
mosaic = cv2.resize(cv2.resize(image, (w // 10, h // 10)), (w, h), interpolation=cv2.INTER_NEAREST)

이미지를 모자이크 처리하는 코드이다.

이렇게 모자이크 처리 된 것을 확인할 수 있다.

(9) 제목 달기

plt.imshow(image)
plt.title("영어로 작성")
plt.axis('off') # 테두리 축 숨기기
plt.show()

상단에 적은 제목이 뜬다.

Original post on Tistory

IRIS - Computer Vision Study · 1차시

Sat, 01 Aug 2026 00:00:00 GMT

1. 컴퓨터 비전이란?

컴퓨터 비전(Computer Vision)은 컴퓨터가 이미지나 비디오와 같은 시각적 데이터를 이해하고 처리할 수 있도록 하는 기술이다.

사람이 사진을 보고 고양이를 알아볼 때 눈, 코, 귀, 얼굴 형태 등의 특징을 이용하는 것처럼 컴퓨터도 이미지 속의 특징(Feature)을 분석하여 대상을 인식한다. 예를 들어 고양이를 인식할 때 뾰족한 두 귀, 둥근 얼굴, 눈의 위치와 같은 특징이 중요한 단서가 될 수 있다.

2. 과거와 현재의 컴퓨터 비전

(1) 전통적인 컴퓨터 비전

딥러닝이 등장하기 전에는 사람이 이미지에서 필요한 특징을 직접 찾아내고, 이를 이용하는 수학적 알고리즘과 규칙을 만들어 컴퓨터에 적용했다.

대표적으로 이미지에서 픽셀 값이 급격하게 변하는 부분을 찾아 선(Edge)을 검출하는 방법 등이 사용되었다.

하지만 사람이 정해 놓은 규칙에 의존하기 때문에 이미지의 빛, 각도, 크기 등의 조건이 조금만 달라져도 인식 성능이 크게 떨어지는 한계가 있었다.

(2) 딥러닝 이후의 컴퓨터 비전

딥러닝이 발전하면서 컴퓨터 비전의 방식도 크게 달라졌다. 사람이 특징을 일일이 정해주는 대신 많은 이미지 데이터와 정답(Label)을 제공하면 모델이 데이터에서 스스로 특징과 규칙을 학습한다.

특히 CNN과 같은 딥러닝 모델은 여러 개의 층(Layer)을 거치면서 점점 복잡한 특징을 추출한다.

얕은 층(Low-level): 선, 모서리, 색상 변화 등
중간 층(Mid-level): 원, 질감, 눈·코와 같은 부분적인 형태
깊은 층(High-level): 얼굴이나 자동차처럼 전체적인 의미

이렇게 여러 단계에서 추출한 정보를 바탕으로 최종적으로 이미지가 무엇인지 판단한다.

3. 컴퓨터의 이미지 인식

컴퓨터의 이미지 인식 과정은 크게 세 단계로 볼 수 있다.

(1) 이미지 입력

컴퓨터는 이미지를 사람처럼 보는 것이 아니라 픽셀의 숫자 배열로 받아들인다.

(2) 특징 추출

딥러닝 모델이 이미지의 픽셀 정보를 분석하여 선, 모양, 질감 등 중요한 특징을 찾아낸다.

(3) 분류

추출한 특징을 바탕으로 여러 카테고리 중 어떤 것에 해당하는지 예측한다. 예를 들어 고양이 사진이라면 고양이일 확률이 가장 높다고 판단할 수 있다.

즉, 딥러닝을 이용한 컴퓨터 비전에서는 이미지 입력 -> 특징 추출 -> 분류의 과정을 모델이 학습을 통해 수행한다.

핵심은 컴퓨터가 스스로 과정을 진행한다는 것이다.

4. 컴퓨터 이미지 인식의 활용

컴퓨터 비전은 목적에 따라 다양한 방식으로 활용된다.

이미지 분류 사진 전체가 무엇인지 판별한다.

객체 검출(Object Detection) 이미지 속 물체의 위치를 찾아 박스로 표시하면서 어떤 물체인지 함께 인식한다.

이미지 분할(Image Segmentation) 이미지의 픽셀 단위로 영역을 나누어 물체의 정확한 경계를 찾는다.

행동 인식(Action Recognition) 여러 프레임의 영상을 분석하여 사람이 어떤 행동을 하고 있는지 판단한다.

5. 컴퓨터 비전에 사용되는 도구

컴퓨터 비전을 구현할 때 다양한 라이브러리와 프레임워크를 사용할 수 있다.

OpenCV: 이미지와 영상을 처리하는 컴퓨터 비전 라이브러리
PyTorch: 딥러닝 모델을 만들고 학습시키는 프레임워크

NumPy: 이미지와 같은 수치 데이터를 배열로 처리하는 수치 연산 라이브러리

PyTorch 외에도 TensorFlow와 같은 딥러닝 프레임워크가 사용된다.

6. 실생활 속 컴퓨터 비전

컴퓨터 비전은 이미 다양한 분야에서 활용되고 있다.

스마트폰의 얼굴 인식 잠금 해제 및 인물 사진 모드

SNS의 카메라 필터
단속 카메라와 CCTV의 객체 및 이상 상황 감지

자율주행 자동차의 주변 차량·보행자 인식

산업 현장의 제품 불량 및 품질 검사
의료 영상 분석을 통한 의료진단 보조

마무리

컴퓨터 비전은 컴퓨터가 이미지와 영상을 분석하여 사람처럼 시각적인 정보를 이해하고 판단할 수 있도록 하는 기술이다.

과거에는 사람이 특징과 규칙을 직접 설계해야 했지만, 딥러닝의 발전으로 많은 데이터와 레이블을 이용해 컴퓨터가 스스로 중요한 특징을 학습하는 방식으로 발전했다.

앞으로도 컴퓨터 비전은 자율주행, 의료, 보안, 제조업 등 다양한 분야에서 더욱 활용될 것으로 기대된다.

Original post on Tistory

IRIS - KBO Hitter Type Analyzer

Sat, 01 Aug 2026 00:00:00 GMT

KBO Hitter Type Analyzer

데이터를 바탕으로 KBO 타자 유형을 분석하는 프로젝트입니다.

AI 비지도 학습을 이용한 KBO 타자 유형 분석

프로젝트명: IRIS KBO 타자 유형 분석
기간: 2026년 IRIS 방학 프로젝트
역할: Developer
분야: AI / Data Analysis / Desktop Application
사용 기술: Python, Tkinter, Requests, BeautifulSoup, Scikit-learn, K-Means, StandardScaler, Threading, PyInstaller
데이터 출처: KBO 공식 기록실

야구를 좋아해서 평소에도 선수들의 타율, 홈런, OPS 같은 기록을 자주 찾아보곤 했다. 그런데 기록을 보다 보니 단순히 타율이 높은 선수와 홈런이 많은 선수를 보는 것에서 끝나는 것이 아니라, 여러 기록을 함께 보면 선수마다 다른 타격 스타일이 보인다는 생각이 들었다.

예를 들어 타율은 높지만 홈런이 많지 않은 선수도 있고, 타율은 조금 낮아도 홈런과 OPS가 높은 선수도 있다. 이런 선수들을 단순히 한 가지 기록으로만 비교하기보다는 여러 기록을 함께 사용해서 비슷한 유형끼리 나눠보면 재미있을 것 같았다. 그래서 2026년 IRIS 방학 프로젝트로 KBO 타자 유형 분석 프로그램을 만들게 됐다.

목표: 최신 KBO 기록을 수집해 비슷한 타격 특성을 가진 선수끼리 자동으로 분류하고, 결과를 쉽게 확인할 수 있는 프로그램 만들기

처음에는 내가 직접 기준을 만들어서 선수를 교타자형, 장타자형으로 나누려고 했다. 예를 들어 타율이 일정 수치 이상이면 교타자형, 홈런이 많으면 장타자형처럼 분류할 수도 있었다. 하지만 그렇게 하면 결국 내가 미리 정한 기준에 맞춰 선수를 나누는 것뿐이라고 생각했다.

그래서 이 프로젝트에서는 선수 유형의 정답을 미리 입력하지 않는 비지도 학습 방식을 사용했다. 비지도 학습은 “이 선수는 장타자형이다” 같은 답을 알려주지 않고, 선수들의 실제 기록만 보고 비슷한 특징을 가진 선수끼리 자동으로 묶는 방식이다. 그중에서도 K-Means 알고리즘을 사용해서 선수들을 두 개의 군집으로 나누었다.

데이터는 2025시즌 기록이나 통산 기록을 사용하지 않고, 반드시 2026시즌 KBO 정규시즌 현재까지 누적된 기록만 사용하도록 구성했다. 또한 프로그램을 실행할 때마다 KBO 공식 기록실에 접속해서 최신 기록을 다시 수집하도록 만들었다. 이미 저장된 오래된 데이터를 사용하는 것이 아니라, 실행 시점에 가능한 최신 기록을 가져오는 방식이다.

수집한 주요 기록은 타율, 홈런, OPS, 볼넷, 삼진이다. 이 다섯 가지 기록을 K-Means 학습에 사용했다. 추가로 경기 수, 타석, 안타, 타점, 출루율, 장타율도 함께 수집해서 사용자가 선수를 검색했을 때 더 많은 정보를 확인할 수 있도록 만들었다.

프로그램을 만들면서 가장 먼저 어려웠던 부분은 데이터 수집이었다. 처음에는 KBO 기록실의 타자 순위 표 하나만 가져오면 될 거라고 생각했다. 하지만 등번호, OPS, 볼넷, 삼진 같은 정보는 기본 기록 표에 모두 들어 있지 않았고, 선수별 세부 기록 페이지에서 따로 확인해야 하는 경우가 있었다.

그래서 기본 기록 페이지에서 선수 이름과 선수 ID를 가져오고, 각 선수의 세부 기록 페이지에 다시 접속해서 필요한 기록을 수집하도록 만들었다. 선수 수가 많기 때문에 한 명씩 순서대로 가져오면 시간이 오래 걸릴 수 있었다. 이를 해결하기 위해 여러 선수의 기록을 동시에 가져오는 방식을 사용했다. 이 과정에서 인터넷 요청, HTML 구조, 페이지마다 다른 데이터 위치 같은 부분을 직접 확인하면서 웹 데이터 수집이 생각보다 복잡하다는 것을 느꼈다.

수집한 데이터를 바로 K-Means에 넣지는 않았다. 타율은 0.2나 0.3처럼 작은 소수점 값이고, 홈런이나 삼진은 수십 단위의 숫자다. 이런 상태로 학습하면 삼진이나 홈런처럼 숫자가 큰 기록이 분석에 더 큰 영향을 줄 수 있다. 그래서 StandardScaler로 모든 기록을 같은 기준으로 변환한 뒤 K-Means를 실행했다.

K-Means는 선수들의 기록을 기준으로 두 개의 군집을 만들지만, 그 결과를 바로 “교타자형”, “장타자형”이라고 알려주지는 않는다. 단순히 0번 군집, 1번 군집처럼 나눠준다. 그래서 각 군집의 평균 홈런과 평균 OPS를 계산해서, 평균 홈런과 OPS가 더 높은 군집을 장타자형으로 해석했다. 반대 군집은 상대적으로 교타자형으로 표시했다.

중요: 교타자형·장타자형이라는 답을 모델에 미리 넣지 않았다. 기록만으로 군집을 만든 뒤, 평균 홈런과 OPS를 바탕으로 사람이 결과를 해석했다.

여기서 중요한 점은 교타자형과 장타자형이라는 라벨을 학습 데이터에 넣지 않았다는 것이다. 모델이 유형명을 외워서 맞힌 것이 아니라, 기록만 보고 비슷한 선수끼리 나눈 뒤 결과를 분석해서 의미를 붙인 것이다. 이 과정을 통해 비지도 학습은 정답을 맞히는 것보다 데이터 속의 패턴을 발견하는 데 활용할 수 있다는 점을 알게 됐다.

프로그램 화면은 Tkinter를 사용해서 만들었다. 사용자가 선수 이름을 입력하면 해당 선수의 팀, 등번호, 타율, 홈런, OPS, 볼넷, 삼진을 확인할 수 있고, 분석 결과로 나온 선수 유형도 함께 볼 수 있다. 처음에는 단순히 콘솔 창에 결과를 출력하는 방식도 생각했지만, 다른 사람이 사용하기에는 화면이 있는 프로그램이 더 편할 것 같았다.

그래서 선수 정보는 카드 형태로 보여주고, 타율·홈런·OPS·볼넷·삼진은 각각 따로 강조해서 표시했다. 또한 프로그램을 실행할 때 데이터 수집 중이라는 상태를 보여주고, 수집 날짜와 수집된 선수 수도 화면에 표시하도록 만들었다. 최종적으로는 PyInstaller를 사용해서 Python이 설치되지 않은 환경에서도 실행할 수 있는 .exe 파일로 변환했다.

이 프로젝트를 하면서 단순히 K-Means 코드를 작성하는 것보다 그 앞뒤 과정이 더 중요하다는 것을 느꼈다. 정확한 데이터를 어디서 가져올지, 데이터를 어떻게 정리할지, 서로 크기가 다른 기록을 어떻게 비교할지, 분석 결과를 어떤 기준으로 해석할지까지 모두 고민해야 했다.

또한 AI는 데이터를 넣으면 자동으로 완벽한 답을 만들어주는 기술이 아니라는 것도 알게 됐다. K-Means가 만든 군집 결과를 보고 어떤 의미를 부여할지 결정하는 과정에는 사람의 해석이 필요했다. 그래서 데이터 분석에서는 모델을 사용하는 능력뿐 아니라 결과를 이해하고 설명하는 능력도 중요하다고 느꼈다.

IRIS 프로젝트는 내가 좋아하는 야구와 AI를 연결해서 직접 만들어본 프로젝트다. 처음에는 선수 기록을 나눠보자는 단순한 생각에서 시작했지만, 실제 데이터를 수집하고, 전처리하고, 머신러닝 모델을 적용하고, 프로그램 화면과 실행 파일까지 만드는 경험으로 이어졌다.

앞으로는 타자 기록뿐 아니라 투수 기록, 수비 기록, 시즌별 기록 변화도 함께 분석해보고 싶다. 또한 군집을 두 개가 아니라 더 다양하게 나누거나, 선수별 그래프와 비교 기능을 추가해서 더 발전된 스포츠 데이터 분석 프로그램으로 만들어보고 싶다.

IRIS - Data Analysis Study · 1차시

Sat, 01 Aug 2026 00:00:00 GMT

1. 데이터 분석이란?

데이터 분석이란 수집된 데이터를 여러 방법으로 처리하고 분석하여 데이터 속에서 의미 있는 정보나 특징을 찾아내는 과정이다.

2. 데이터 분석 과정

데이터 분석은 데이터를 단순히 확인하는 것이 아니라, 문제를 정의하고 데이터를 수집·정리한 뒤 분석을 통해 의미 있는 결과를 찾아가는 과정이다.

(1) 문제 정의

가장 먼저 무엇을 분석할 것인지 목표를 정한다.

(2) 데이터 수집

분석에 필요한 데이터를 수집한다.

수집 방법: 데이터는 공공데이터, CSV 파일, 데이터베이스, API, 웹 크롤링 등 다양한 방법으로 얻을 수 있다.

(3) 데이터 정제

수집한 데이터에는 결측치나 중복값, 이상치 등이 포함될 수 있다. 이런 데이터를 수정하거나 제거하여 분석하기 좋은 형태로 정리하는 과정이다.

(4) 탐색적 데이터 분석

정리된 데이터를 그래프나 통계값으로 확인하며 데이터의 특징과 패턴을 찾아보는 과정이다. 이를 통해 변수 간의 관계나 예상하지 못했던 특징을 발견할 수 있다.

(5) 모델링 및 분석

분석 목적에 맞게 통계 기법이나 머신러닝 모델을 활용한다. 예측, 분류, 군집화 등 문제에 적절한 방법을 선택하여 데이터를 분석한다.

(6) 시각화 및 해석

분석 결과를 그래프나 차트로 표현하여 쉽게 이해할 수 있도록 만든다. 단순히 시각화하는 것뿐만 아니라 결과가 어떤 의미를 가지는지 해석하는 과정도 중요하다.

(7) 인사이트 도출 및 활용

마지막으로 분석 결과를 바탕으로 실제 문제 해결이나 의사결정에 활용할 수 있는 결론을 도출한다.

데이터 분석은 이러한 과정을 반복하면서 데이터 속에서 의미 있는 정보를 발견하고, 이를 실제 문제 해결에 활용하는 과정이라고 할 수 있다.

3. 데이터 시각화

데이터를 그래프나 차트로 나타내어 데이터의 특징이나 변화를 한눈에 이해할 수 있도록 하는 것이다.

4. Numpy

NumPy는 데이터 분석과 시각화에 필요한 수치 계산을 효율적으로 처리하기 위한 라이브러리이다.

(1) numpy 불러오기

import numpy as np

numpy를 import 해 불러오는 코드이다.

(2) 배열 만들기

data = np.array([10, 20, 30, 40, 50])

print(data)

print(data[0])

print(data[2])

배열을 만드는 코드이다. 순서대로 데이터 전체 출력, 배열 0번째 값, 배열 2번째 값을 출력하는 코드이다.

(3) 일정한 배열 만들기

data = np.arange(1, 10)

print(data)

데이터를 1~ 9까지 배열로 만들고 출력하는 코드이다.

[1,2,3,4,5,6,7,8,9]가 출력될 것이다.

(4) 특정한 배열 만들기

print(np.zeros(5)) // 0 배열
print(np.ones(5)) // 1배열

첫 번째 코드는 0을 5개만큼 넣은 배열을 만들고 두 번째 코드는 1을 5개만큼 넣은 배열을 만드는 코드이다.

[0,0,0,0,0]이 출력될 것이다.
[1,1,1,1,1]이 출력될 것이다.

(5) 데이터 분석하기

data = np.array([72, 85, 91, 64, 88, 95, 78, 83])

print("평균:", np.mean(data))
print("최댓값:", np.max(data))
print("최솟값:", np.min(data))
print("합계:", np.sum(data))
print("표준편차:", np.std(data))

데이터를 배열로 만든 뒤 순서대로 평균, 최댓값, 최솟값, 합계, 표준편차를 계산해 주는 코드이다.

데이터의 평균: 82.0

데이터의 최댓값: 95

데이터의 최솟값: 64

데이터의 합계: 656

데이터의 표준편차: 9.591663046625438 이 출력될 것이다.

(6) 연습하기

배열의 모든 요소를 출력하세요.
배열의 요소 중 최댓값을 출력하세요.
배열의 요소 중 최솟값을 출력하세요.
배열의 요소의 평균값을 출력하세요.
배열의 형태를 2행 5열로 변경한 후 출력하세요. 단, 새로운 변수를 만들어 사용하세요.

사용하는 데이터 -> scores = np.array([75, 82, 91, 68, 88, 95, 79, 84, 90, 73])

풀이

scores = np.array([75, 82, 91, 68, 88, 95, 79, 84, 90, 73])

print(data) #배열 전체 출력
print(np.max(data))#최댓값 출력
print(np.min(data)) #최솟 출력
print(np.mean(data)) # 평균 출력
a = scores.reshape(2,5) # 2행 5열
print(a)

(7) Numpy의 주요 명령어

np.array()	배열 생성	np.array([1, 2, 3])
np.arange()	일정한 간격으로 배열 생성	np.arange(1, 10) → 1부터 9까지 생성
np.zeros()	0으로 채워진 배열 생성	np.zeros(5) → 0을 5개 생성
np.ones()	1로 채워진 배열 생성	np.ones(5) → 1을 5개 생성
np.mean()	평균 계산	np.mean(data)
np.max()	최댓값 계산	np.max(data)
np.min()	최솟값 계산	np.min(data)
np.sum()	전체 합계 계산	np.sum(data)
np.std()	표준편차 계산	np.std(data)
np.reshape()	배열의 형태 변경	data.reshape(2, 3) → 2행 3열로 변경

5. pandas

Python에서 표 형태의 데이터를 쉽게 다루고 분석할 수 있도록 도와주는 라이브러리이다.

(1) pandas 불러오기

import pandas as pd

pandas를 import 해 불러오는 코드이다.

(2) 데이터 만들기

data = {

'이름': ['A', 'B', 'C', 'D', 'E'], # 이름 데이터
'점수': [80, 90, 75, 95, 85], # 점수 데이터
'학년': [1, 1, 2, 2, 1] # 학년 데이터

}

data는 학생의 이름, 점수, 학년 정보를 딕셔너리 형태로 저장한 데이터이다. 각 항목은 리스트로 구성되어 있으며, 이후 Pandas의 DataFrame으로 변환해 표 형태로 사용할 수 있다.

(3) Dataframe으로 변환후 출력

df = pd.DataFrame(data)
print(df)

데이터를 Dataframe으로 변환해 표로 출력하는 코드이다.

이름 점수 학년

0 A 80 1

1 B 90 1

2 C 75 2

3 D 95 2

4 E 85 1

이렇게 출력된다.

(4) 데이터 출력하기

print(df.head())

데이터의 처음 5개 값이 출력된다.

(5) 특정 열 데이터 출력

print(df['점수'])

특정 열 데이터 출력을 하는 코드이다.

(6) 데이터 분석

# 점수의 평균 계산
print("평균:", df['점수'].mean())

# 점수의 최댓값 계산
print("최댓값:", df['점수'].max())

# 점수의 최솟값 계산
print("최솟값:", df['점수'].min())

데이터의 평균 , 최댓값 , 최솟값을 계산하는 코드이다.

(7) 수치 데이터의 기본 통계 정보출력

print(df.describe())

(8) 연습하기

전체 데이터를 출력하세요.
‘점수’ 열의 데이터를 출력하세요.
점수의 평균값을 출력하세요.
점수의 최댓값을 출력하세요.
점수의 최솟값을 출력하세요.
describe()를 이용하여 기본 통계 정보를 확인하세요.
head()를 이용하여 데이터의 처음 5개 행을 출력하세요.

풀이

data = {
    '이름': ['A', 'B', 'C', 'D', 'E'],
    '점수': [78, 92, 85, 96, 74],
    '학년': [1, 1, 2, 2, 1]
}
df = pd.DataFrame(data)
print(df)                         # 전체 데이터 출력

print(df['점수'])                 # 점수 열 출력

print("평균:", df['점수'].mean())   # 평균 계산

print("최댓값:", df['점수'].max()) # 최댓값 계산

print("최솟값:", df['점수'].min()) # 최솟값 계산

print(df.describe())              # 통계 정보 출력

print(df.head())                  # 처음 5개 행 출력

(8) pandas의 주요 명령어

명령어기능예시

pd.DataFrame()	데이터프레임 생성	pd.DataFrame(data)
df.head()	처음 5개의 데이터 확인	df.head()
df.tail()	마지막 5개의 데이터 확인	df.tail()
df.info()	데이터의 기본 정보 확인	df.info()
df.describe()	수치형 데이터의 통계 정보 확인	df.describe()
df['열이름']	특정 열 선택	df['점수']
df.mean()	평균 계산	df['점수'].mean()
df.max()	최댓값 계산	df['점수'].max()
df.min()	최솟값 계산	df['점수'].min()

Original post on Tistory

Sunrin Hackathon

Wed, 01 Jul 2026 00:00:00 GMT

Sunrin Hackathon

대회에서 맡은 역할과 개발 과정, 결과를 기록합니다.

선린 해커톤은 이전부터 정보보호과에서는 본선 진출 팀이 많이 나오지 않는 대회라는 이야기를 들어서 예선에 지원하면서도 큰 기대를 하지는 않았다. 그런데 예상을 깨고 정보보호과에서 유일하게 본선에 진출한 팀이 되었다는 소식을 들었을 때 굉장히 뿌듯하고 자랑스러웠다.

이번 해커톤 생활 부문의 주제는 **‘깨다’**였다. 처음 주제를 들었을 때는 생각보다 추상적이어서 무엇을 깨야 할지 정하는 것부터 고민이 많았다. 팀원들과 여러 방향으로 이야기를 나누던 중 사회 교과서에서 접했던 **‘정보격차 문제’**가 떠올랐다. 디지털 기술은 계속 발전하고 있지만 이를 자유롭게 활용하는 사람과 그렇지 못한 사람 사이의 격차는 여전히 존재한다는 점에 주목했고, 우리는 **‘정보 격차를 깨다’**라는 의미로 프로젝트의 방향을 정했다.

그렇게 시작한 프로젝트가 **‘이음(IEUM)’**이다. 이음은 디지털 환경에 익숙하지 않은 사람들과 일상 속 디지털 서비스를 이어 준다는 의미를 담은 서비스다. 키오스크나 모바일 앱, 온라인 쇼핑처럼 누군가에게는 당연하고 편리한 기술도 처음 사용하는 사람에게는 낯선 화면과 복잡한 절차 때문에 큰 장벽이 될 수 있다고 생각했다. 그래서 실제 서비스를 이용하기 전에 실수에 대한 부담 없이 반복해서 연습할 수 있는 환경을 만들어 정보격차를 줄이고자 했다.

나는 프로젝트에서 Developer 역할을 맡아 실제 기능을 구현하는 데 집중했다. 먼저 디지털 환경에서 자주 등장하는 용어들을 익힐 수 있는 단어 학습 기능을 만들었고, 사용자가 원하는 실습을 직접 선택할 수 있도록 구성했다. 키오스크 실습에서는 메뉴 선택부터 수량 변경, 결제 방식 선택, 영수증 확인까지 실제 주문 과정과 비슷하게 경험할 수 있도록 했다. 온라인 쇼핑에 익숙하지 않은 사용자를 위해 상품을 선택하고 구매 과정을 연습할 수 있는 쿠팡 실습 기능도 구현했다.

개발 과정에서 멘토분들께 한 번의 체험으로 끝나면 학습을 지속하기 어렵다는 피드백을 받았고, 이를 보완하기 위해 게임 실습과 랭킹 시스템도 추가했다. 사용자가 실습 과정에서 점수를 얻고 자신의 결과를 확인할 수 있게 함으로써 단순히 기능을 설명하는 서비스가 아니라 반복해서 사용하고 싶은 서비스로 만들고자 했다. 처음에는 아이디어로만 존재하던 기능들이 하나씩 실제 화면으로 구현되는 모습을 보면서 개발자로서 큰 성취감을 느낄 수 있었다.

특히 이번 대회는 24시간 동안 기획부터 개발, 발표 준비까지 모두 진행해야 하는 해커톤이었기 때문에 체력적으로도 쉽지 않았다. 밤새 개발을 이어 가다 보니 정말 피곤했고, 제한된 시간 때문에 원하는 기능을 모두 완벽하게 구현하기도 어려웠다. 그래도 팀원들과 계속 의견을 맞추고 문제를 해결하면서 키오스크 실습, 온라인 쇼핑 실습, 게임과 랭킹 등 하나하나 기능이 완성되어 가는 과정을 직접 확인할 때마다 힘든 것 이상으로 뿌듯함을 느꼈다.

최종적으로 수상까지 이어지지는 못해서 아쉬움은 남았다. 하지만 정보보호과에서 유일하게 본선에 진출해 24시간 동안 하나의 프로젝트를 직접 완성해 본 경험 자체가 나에게는 큰 의미가 있었다. 단순히 코드를 작성하는 것뿐만 아니라 사용자가 실제로 어떤 부분에서 어려움을 느끼는지 고민하고, 멘토의 피드백을 받아 기능을 개선하며, 제한된 시간 안에서 팀원들과 결과물을 완성하는 과정까지 경험할 수 있었다.

이번 해커톤을 통해 내가 부족한 부분도 많이 발견했지만, 동시에 이전보다 더 긴 시간 동안 집중해서 하나의 프로젝트를 만들어 낼 수 있다는 자신감도 얻었다. 비록 수상하지는 못했지만 개발자로서 한 층 더 발전할 수 있었던 계기가 된 대회였고, 다음 해커톤에서는 이번 경험을 바탕으로 더 완성도 높은 프로젝트를 만들어 좋은 결과까지 얻어 보고 싶다.

Sunrin Hackathon - IEUM

Wed, 01 Jul 2026 00:00:00 GMT

Sunrin Hackathon - IEUM

역할: Developer
주제: 깨다
핵심 메시지: 정보 격차를 깨다
프로젝트명: 이음(IEUM)

선린 해커톤에서 주제인 **“깨다”**를 어떻게 해석할지 팀원들과 먼저 고민했다. 우리 팀은 디지털 기술이 빠르게 발전하는 만큼, 이를 익숙하게 사용하는 사람과 그렇지 않은 사람 사이의 정보 격차도 커지고 있다는 점에 주목했다.

특히 키오스크, 모바일 앱, 온라인 쇼핑, AI 서비스처럼 일상에서 자주 접하는 기술들이 누군가에게는 편리하지만, 다른 누군가에게는 큰 진입 장벽이 될 수 있다고 생각했다. 그래서 우리는 **“정보 격차를 깨다”**라는 방향으로, 디지털 소외계층이 생활 속 디지털 서비스를 부담 없이 연습할 수 있는 프로그램 이음을 제작했다.

이음은 디지털 기술을 배우는 사람과 일상 속 디지털 서비스를 연결해 주는 실습형 학습 서비스다.

문제를 발견한 과정

자료를 조사하면서 연령이 높아질수록 디지털 정보화 활용 수준이 낮아지는 흐름을 확인했다. 단순히 기기를 사용할 수 있는지의 문제가 아니라, 주문·결제·예약처럼 일상에서 필요한 서비스를 스스로 이용할 수 있는지가 중요한 문제라고 느꼈다.

누군가에게는 몇 번의 클릭이면 끝나는 일이지만, 디지털 환경에 익숙하지 않은 사람에게는 잘못 눌렀을 때의 부담과 낯선 화면 자체가 큰 장벽이 될 수 있다. 이음은 실제 서비스에 바로 들어가기 전, 실수해도 괜찮은 연습 공간을 제공하는 것을 목표로 했다.

주요 기능

단어 학습

디지털 환경에서 자주 보이는 용어를 먼저 익힐 수 있도록 단어 학습 기능을 만들었다. 익숙하지 않은 표현을 작은 단위부터 반복해서 볼 수 있게 구성해, 이후 실습 화면을 볼 때의 부담을 줄이고자 했다.

실습 시작하기

사용자가 어떤 기능을 연습할지 직접 고를 수 있는 시작 화면을 만들었다. 단순히 정보를 설명하는 데서 끝내지 않고, 사용자가 화면을 눌러 보면서 절차를 익히도록 흐름을 구성했다.

키오스크 실습

키오스크 실습에서는 메뉴를 고르고, 수량을 변경하고, 결제 방식을 선택한 뒤 영수증을 확인하는 과정까지 직접 따라 해볼 수 있다. 화면 단계마다 안내 문구를 넣어 다음에 무엇을 해야 하는지 알 수 있게 만들었다.

특히 결제 단계에서는 QR 결제와 쿠폰 결제처럼 실제로 낯설 수 있는 선택지를 보여주고, 주문이 끝난 뒤에는 영수증 화면까지 제공했다. 사용자가 한 번에 외우기보다 여러 번 반복해 보면서 익숙해지는 것을 중요하게 생각했다.

쿠팡 실습

온라인 쇼핑 화면을 활용한 실습도 넣었다. 상품 목록을 보고 필요한 물건을 고른 뒤 구매 흐름을 경험할 수 있도록 만들었다. 실제 결제가 일어나지 않는 안전한 환경에서 온라인 구매의 순서를 익힐 수 있다는 점이 핵심이다.

게임 실습과 랭킹 시스템

디지털 학습은 한 번 해보고 끝나면 지속성이 떨어질 수 있다는 의견을 멘토분들께 들었다. 그래서 학습을 계속 이어갈 수 있도록 게임 실습과 랭킹 시스템을 추가했다.

사용자는 실습을 진행하면서 점수를 얻고, 랭킹을 통해 자신의 학습 결과를 확인할 수 있다. 단순한 경쟁만을 위한 기능이 아니라, 반복 학습의 동기를 만들고 “다음에도 한 번 더 해보자”는 흐름을 만들기 위해 개발했다.

랭킹 시스템은 재미 요소이면서 동시에 학습의 지속성을 높이기 위한 장치였다.

기대한 변화

이음을 통해 기대한 변화는 단순히 기능 하나를 익히는 것이 아니었다. 디지털 기기를 사용할 때 느끼는 막연한 두려움을 줄이고, 반복 실습을 통해 **“나도 할 수 있다”**는 자신감을 만드는 것이 더 중요하다고 생각했다.

디지털 정보격차 감소
디지털 서비스 사용에 대한 자신감 향상
반복 학습을 통한 사용 흐름 익히기
주문과 구매처럼 실생활에서 바로 활용할 수 있는 경험 제공

24시간 해커톤 경험

이번 프로젝트는 24시간 동안 기획부터 개발까지 완성해야 하는 해커톤이었다. 제한된 시간 안에 문제를 정하고, 기능을 정리하고, 화면을 만들고, 발표 자료까지 준비해야 해서 과정 자체는 정말 힘들었다.

그래도 짧은 시간 안에 팀원들과 계속 의견을 맞추고, 기능을 하나씩 구현하면서 프로젝트가 실제 결과물의 형태를 갖춰 가는 과정이 인상 깊었다. 특히 처음에는 아이디어였던 것이 키오스크 주문 화면, 쿠팡 실습 화면, 게임과 랭킹 화면으로 눈앞에 나타났을 때 뿌듯함을 크게 느꼈다.

힘들었던 만큼, 제한된 시간 안에 사용자가 직접 체험할 수 있는 결과물을 만들었다는 점에서 좋은 경험이었다.

느낀 점과 앞으로의 방향

이번 해커톤을 통해 기능을 많이 넣는 것만큼이나, 사용자가 실제로 어려워하는 지점을 찾고 쉽게 안내하는 것이 중요하다는 것을 배웠다. 이음은 디지털에 익숙한 사람이 아니라, 디지털 환경을 처음 접하거나 어려워하는 사람을 기준으로 생각해 본 프로젝트였다.

앞으로는 더 다양한 생활 서비스 실습을 추가하고, 학습 난이도를 사용자의 수준에 맞게 조절하는 기능도 넣어보고 싶다. 또한 랭킹뿐 아니라 학습 기록, 복습 추천, 단계별 목표 같은 기능을 발전시켜 지속해서 사용할 수 있는 디지털 생활 학습 서비스로 만들어 보고 싶다.

IRIS - Deep Learning Study · 1차시

Wed, 01 Jul 2026 00:00:00 GMT

1. 인공지능이란?

인공지능(AI, Artificial Intelligence)이란 사람의 학습, 추론, 문제 해결, 언어 이해, 인식과 같은 지능적인 능력을 컴퓨터가 수행하도록 만드는 기술을 말합니다.

2. 인공지능의 포함 관계

(1) 인공지능: 인간의 지능을 모방하는 기술

(2) 머신러닝: 데이터로부터 규칙을 스스로 학습하는 기술

(3) 딥러닝: 인공 신경망을 기반으로 하여, 비정형 데이터부터 특징 추출 및 판단까지 수행하는 기술

3. AI의 역사

인공지능(AI)은 1950년대부터 본격적으로 연구되기 시작했습니다. 초기에는 컴퓨터가 사람처럼 생각하고 문제를 해결할 수 있을지에 대한 연구가 중심이었으며, 규칙을 사람이 직접 입력하는 방식의 기호적 인공지능이 주로 사용되었습니다.

이후 1980~1990년대에는 데이터를 이용해 컴퓨터가 스스로 규칙을 찾아가는 머신러닝이 발전하기 시작했습니다. 하지만 당시에는 데이터와 컴퓨터의 성능이 부족해 지금과 같은 높은 수준의 AI를 구현하기에는 한계가 있었습니다.

그리고 2000년대 이후 세 가지 혁신이 만나면서 AI가 급격하게 발전했습니다.

Big Data: 인터넷과 스마트폰 등의 발전으로 AI가 학습할 수 있는 방대한 디지털 데이터가 만들어졌습니다.
Computing Power: GPU와 같은 하드웨어의 발전으로 대량의 데이터를 빠르게 처리하고 복잡한 계산을 수행할 수 있게 되었습니다.
Algorithm: 신경망 구조와 학습 방법이 발전하면서 AI가 데이터를 더욱 효율적으로 학습할 수 있게 되었습니다.

특히 이러한 세 가지 요소가 결합하면서 딥러닝이 크게 발전했고, 이미지 인식·음성 인식·자연어 처리 등 다양한 분야에서 AI의 성능이 급격히 향상되었습니다. 이후 생성형 AI와 대규모 언어 모델까지 발전하면서 오늘날에는 AI가 글, 이미지, 음성, 영상 등을 생성하는 단계에 이르렀습니다.

4. 인공지능의 모티브

인공지능은 인간의 뇌가 정보를 처리하고 판단하는 방식에서 큰 영감을 받았습니다.

우리 뇌에는 약 1000억 개의 뉴런(Neuron)이 존재하며, 뉴런들은 서로 연결되어 전기·화학적 신호를 주고받습니다. 뉴런은 전달받은 신호가 일정 수준을 넘으면 다음 뉴런으로 신호를 전달하는 방식으로 정보를 처리합니다.

이러한 생물학적 뉴런의 구조와 정보 처리 방식을 수학적으로 모방한 것이 인공 신경망(Artificial Neural Network)입니다.

인공 신경망에서는 실제 뉴런 대신 인공 뉴런을 사용하고, 여러 입력값에 가중치를 적용하여 신호를 계산합니다.

이렇게 여러 인공 뉴런을 연결하고 여러 층으로 구성한 것이 딥러닝의 기본 구조가 됐습니다.

5. 퍼셉트론

퍼셉트론(Perceptron)은 인공 신경망의 가장 기본적인 형태로, 사람의 뉴런이 여러 신호를 받아 하나의 판단을 내리는 과정을 수학적으로 표현한 모델입니다.

퍼셉트론에는 가중치, 편향등이 사용됩니다.

(1) 가중치

각 입력 정보가 정답을 맞히는 데 얼마나 중요한지 나타내는 수치입니다. 학습의 목표는 바로 이 가중치를 찾는 것입니다.

(2) 편향

뉴런이 얼마나 쉽게 활성화될지 결정하는 민감도입니다.

모델이 데이터의 편향성을 조절하도록 돕습니다.

6. 딥러닝의 구조

(1) 딥러닝의 층(Layer)

딥러닝은 인공 뉴런들이 여러 층으로 연결되어 있는 구조입니다. 하나의 층에서 처리한 정보가 다음 층으로 전달되면서 점점 더 복잡한 특징을 학습합니다.

입력층(Input Layer): 학습에 사용할 데이터가 들어오는 층 -> 야구 선수라면 타율, 홈런 수, 출루율, 타점 등의 데이터가 입력됨
은닉층(Hidden Layer): 입력된 데이터를 바탕으로 특징과 패턴을 학습하는 층 -> 앞쪽 층에서는 타율이나 홈런 같은 개별적인 특징을 분석하고, 뒤쪽 층에서는 여러 데이터를 조합하여 선수의 타격 성향이나 특징을 학습할 수 있음 -> 은닉층이 여러 겹으로 깊게 쌓여 있기 때문에 'Deep Learning'이라고 부름
출력층(Output Layer): 은닉층에서 학습한 특징을 종합하여 최종 결과를 출력하는 층 -> 예를 들어 선수의 데이터를 분석하여 장타형 선수일 확률 85%와 같은 결과를 출력할 수 있음

7. 딥러닝의 학습

(1) 1단계 순전파

입력 데이터를 입력층에서 출력층까지 전달하여 예측값을 계산합니다.

(2) 2단계 손실 함수 (오차)

모델의 예측값과 실제 정답을 비교하여 얼마나 틀렸는지 계산합니다.

(3) 3단계 역전파

계산된 오차를 출력층에서 입력층 방향으로 전달하면서 각 가중치와 편향이 오차에 미친 영향을 계산합니다.

(4) 무한 반복 에포크

Epoch:전체 데이터를 한 번 학습

반복할수록 손실값(Loss)은 감소 정확도(Accuracy)는 점점 상승하여 완벽해집니다.

너무 많이 학습하면 과적합(Overfitting)이 발생합니다.

8. 딥러닝의 이용 분야

컴퓨터 비전 자율주행, 얼굴 인식, 의료 영상 분석 등 시각적 이해

자연어 처리 챗GPT, 자동 번역기, 감성 분석 등 언어 이해

생성형 AI 이미지 생성, 음악 작곡, 코드 작성 등 창작 영역

9. 딥러닝의 한계와 미래

강력한 기술이지만 아직 풀어야 할 숙제들이 남아 있습니다.

(1) 블랙박스 현상

딥러닝은 수많은 뉴런과 가중치를 이용해 결과를 만들어내기 때문에, 왜 특정한 결과를 내렸는지 사람이 정확하게 이해하기 어려운 경우가 있습니다. 예를 들어 AI가 어떤 사진을 보고 "고양이"라고 판단했을 때, 정확히 어떤 특징을 근거로 판단했는지 설명하기 어려울 수 있습니다.

(2) 자원 소모

대규모 딥러닝 모델을 학습시키기 위해서는 많은 데이터와 높은 컴퓨팅 성능이 필요합니다. 특히 GPU와 같은 고성능 하드웨어를 장시간 사용하면서 상당한 전력과 비용이 발생할 수 있습니다.

(3) 미래

이러한 문제를 해결하기 위해 설명 가능한 AI(XAI)와 효율적인 AI 모델이 연구되고 있습니다. XAI는 AI가 어떤 근거로 결과를 판단했는지 사람이 이해할 수 있도록 설명하는 것을 목표로 하며, 효율적인 학습 모델은 더 적은 데이터와 컴퓨팅 자원으로도 높은 성능을 내는 것을 목표로 합니다.

즉, 앞으로의 AI는 단순히 성능이 높은 것을 넘어, 왜 그런 판단을 했는지 설명할 수 있고 적은 자원으로 효율적으로 작동하는 방향으로 발전할 필요가 있습니다.

Original post on Tistory

IRIS - Python Study · 3차시

Wed, 03 Jun 2026 00:00:00 GMT

객체지향 프로그래밍(OOP, Object-Oriented Programming)은 현실 세계의 사물이나 개념을 프로그램 안의 객체(Object) 로 표현하여 개발하는 방식입니다.

객체는 단순한 데이터가 아니라 데이터(속성) 와 기능(메서드) 을 하나로 묶은 것입니다. 즉, 객체는 상태와 행동을 함께 가지고 있습니다.

예를 들어 사람을 객체로 표현한다면 이름, 나이, 직업과 같은 데이터(속성)가 있고, 걷기, 생각하기, 눕기와 같은 기능(행동)이 있습니다. 이처럼 관련된 데이터와 기능을 하나로 묶은 것이 객체입니다.

객체지향 프로그래밍에서는 이러한 객체들을 중심으로 프로그램을 설계합니다. 객체들은 서로 정보를 주고받으며 필요한 기능을 수행하고, 이를 통해 복잡한 프로그램도 체계적으로 구성할 수 있습니다.

객체지향 프로그래밍이 등장하기 전에는 주로 절차지향 프로그래밍을 사용했습니다. 절차지향 프로그래밍에서는 데이터와 기능이 분리되어 있어 프로그램 규모가 커질수록 관리가 어렵고, 코드 재사용이 힘들다는 단점이 있습니다.

반면 객체지향 프로그래밍은 데이터와 기능을 하나로 묶어 관리하기 때문에 유지보수가 쉽고, 코드의 재사용성이 높으며, 대규모 프로그램 개발에 유리합니다. 이러한 이유로 현재는 웹, 게임, 앱, 인공지능 등 다양한 분야에서 객체지향 프로그래밍이 널리 사용되고 있습니다.

기존 방식은 많은 사람들을 하나하나 작성해야 한다는 단점이 있어 관리가 불가능하다.

객체지향을 사용하면 하나의 객체로 표현 할 수 있다.

클래스(Class)

객체를 만들기 위한 설계도
클래스로부터 객체(인스턴스)를 생성함

Ex. "야구 선수 클래스"

데이터(속성)

이름
등번호
포지션
타율
홈런 수

기능(동작)

타격한다
수비한다
주루한다
훈련한다

속성과 메서드: 객체의 데이터와 행동

hit()은 객체가 수행할 수 있는 메서드(Method) 로, 객체의 행동이나 기능을 의미한다.

player1 = BaseballPlayer("양의지")를 통해 BaseballPlayer 클래스로부터 player1이라는 객체를 생성하였다.

player1.hit()을 실행하면 hit() 메서드가 호출되어 "안타!"가 출력된다.

객체지향의 핵심 4가지

캡슐화 (Encapsulation)

캡슐화는 객체의 데이터를 외부에서 함부로 접근하지 못하도록 보호하고, 필요한 기능을 통해서만 접근하도록 만드는 것이다.

예를 들어 야구 선수의 연봉 정보를 아무 곳에서나 수정할 수 없게 하고, 정해진 메서드를 통해서만 조회하거나 변경하도록 만들 수 있다.

상속 (Inheritance)

상속은 기존 클래스의 속성과 메서드를 물려받아 새로운 클래스를 만드는 것이다.

다형성 (Polymorphism)

다형성은 같은 이름의 메서드가 객체에 따라 다른 방식으로 동작하는 것이다.

예를 들어 투수와 타자 모두 play() 메서드를 사용할 수 있지만 수행하는 행동은 다를 수 있다.

추상화 (Abstraction)

추상화는 객체의 중요한 특징만 보여주고 복잡한 내부 구현은 숨기는 것이다.

예를 들어 자동차의 운전자는 엔진의 모든 동작 원리를 몰라도 핸들과 페달만으로 운전할 수 있다.

Original post on Tistory

IRIS - Python Study · 2차시

Tue, 02 Jun 2026 00:00:00 GMT

이번 파이썬 수업에서는 여러 데이터를 효율적으로 관리할 수 있는 자료형인 리스트, 튜플, 딕셔너리를 배웠다. 또한 반복문을 간결하게 표현할 수 있는 리스트 컴프리헨션도 함께 살펴보았다.

리스트(List)

리스트는 여러 개의 데이터를 하나로 묶어서 관리하는 자료형이다.

데이터에 순서가 있으며, 대괄호를 사용해 만든다.

python shopping_list = ["우유", "빵", "계란", "사과"] numbers = [1, 2, 3, 4, 5] mixed = ["안녕", 42, True]

리스트는 다음과 같은 특징을 가진다.

데이터에 순서가 있으며 첫 번째 위치는 0번이다.
생성한 뒤에도 원소를 수정할 수 있다.
같은 값을 여러 번 저장할 수 있다.
서로 다른 자료형의 데이터를 함께 저장할 수 있다.

리스트 원소 접근하기

리스트의 각 원소에는 인덱스를 이용해 접근할 수 있다. 음수 인덱스를 사용하면 뒤에서부터 접근할 수도 있다.

python fruits = ["사과", "바나나", "오렌지", "포도"]

print(fruits[0]) # 사과 print(fruits[1]) # 바나나 print(fruits[-1]) # 포도

리스트의 주요 메서드

python fruits.append("딸기") # 리스트 끝에 원소 추가 fruits.remove("바나나") # 특정 원소 삭제 print(len(fruits)) # 리스트 길이 확인

append()는 새로운 값을 추가하고, remove()는 원하는 값을 삭제한다. len()을 사용하면 리스트에 저장된 원소의 길이를 알 수 있다.

리스트 컴프리헨션(List Comprehension)

리스트 컴프리헨션은 반복문으로 리스트를 만드는 과정을 한 줄로 간결하게 표현하는 방법이다. 조건을 추가하거나 문자열 메서드와 함께 사용할 수도 있다. 리스트 컴프리헨션은 코드를 짧고 명확하게 만들 수 있지만, 조건이 너무 복잡하면 일반 반복문이 더 읽기 쉬울 수 있다.

튜플(Tuple)

튜플은 리스트와 비슷하게 순서가 있는 여러 데이터를 저장하지만, 생성한 후에는 값을 수정할 수 없다. 소괄호 ()를 사용하며, 좌표나 색상처럼 변하지 않아야 하는 데이터를 저장할 때 유용하다.

python point = (3, 5) colors = ("빨강", "초록", "파랑") red = (255, 0, 0)

딕셔너리(Dictionary)

딕셔너리는 키(key)와 값(value)을 한 쌍으로 묶어 저장하는 자료형이다. 사전에서 단어를 찾듯이 키를 사용해 원하는 값을 빠르게 찾을 수 있으며, 중괄호 {}를 사용한다.

python student = { "이름": "김철수", "나이": 20, "전공": "컴퓨터공학" }

딕셔너리의 값은 키를 이용해 조회하거나 수정할 수 있다.

python print(student["이름"]) # 김철수

student["학년"] = 2 # 새로운 데이터 추가 student["나이"] = 21 # 기존 값 수정 del student["전공"] # 데이터 삭제

딕셔너리 주요 메서드

python student.keys() # 모든 키 student.values() # 모든 값 student.items() # 키와 값의 쌍 student.get("이름") # 키에 해당하는 값 student.clear() # 모든 데이터 삭제

정리

마무리

이번 수업을 통해 여러 데이터를 상황에 맞게 저장하고 관리하는 방법을 배웠다. 값의 순서와 수정이 필요하다면 리스트, 변경되면 안 되는 데이터라면 튜플, 이름이나 속성처럼 키를 기준으로 값을 찾고 싶다면 딕셔너리를 사용하는 것이 좋다.

Original post on Tistory

Doosan Bears Fan Dashboard

Mon, 01 Jun 2026 00:00:00 GMT

Doosan Bears Fan Dashboard

두산 베어스 관련 정보를 한곳에서 볼 수 있는 대시보드 프로젝트입니다.

평소 야구 경기를 자주 봐서 야구에 관심이 많은데, 경기를 보다 보면 팀 순위나 선수 기록을 확인하고 싶을 때가 많았다. 필요한 정보들이 여러 사이트에 나누어져 있어서 매번 따로 찾아봐야 하는 점이 불편했다. 또 경기 전에는 상대 팀과 비교했을 때 두산 베어스가 이길 확률이 얼마나 되는지, 시즌 중에는 최종적으로 몇 위를 할 가능성이 높은지 궁금할 때가 많았다. 이런 궁금증과 불편함을 직접 해결해 보고 싶다는 생각이 들어 **두산 베어스 팬들을 위한 웹 대시보드인 ‘Bears Lab’**을 개발하게 되었다.

프로젝트는 Python과 Flask를 이용해 제작했다. 먼저 네이버 스포츠의 KBO 데이터와 두산 베어스 선수단 데이터를 가져와 팀 순위와 선수 기록 등을 확인할 수 있도록 만들었다. 단순히 정보를 보여주는 사이트로 끝내기보다는 내가 야구 팬으로서 실제로 사용하고 싶은 기능을 넣고 싶었다. 그래서 상대 팀의 전력과 홈·원정 여부 등을 이용해 경기의 승리 확률을 예상하는 기능을 만들었고, 현재 팀 성적과 남은 경기 등을 바탕으로 여러 번의 시뮬레이션을 진행해 시즌 예상 최종 순위를 보여주는 기능도 구현했다. 이외에도 선수 기록과 프로필을 확인하는 기능, 선수 응원가를 들을 수 있는 기능, 야구 퀴즈 등 여러 기능을 추가했다.

이 프로젝트를 진행하면서 단순히 웹 페이지 화면을 만드는 것뿐만 아니라 실제 데이터를 가져오고, 필요한 형태로 가공한 뒤 웹사이트에 표시하는 과정을 직접 경험할 수 있었다. 처음에는 데이터를 원하는 형태로 불러오지 못하거나 기능이 생각한 대로 작동하지 않는 경우도 있었지만, 코드를 하나씩 확인하고 수정하면서 문제를 해결해 나갔다. 그 과정에서 새로운 기능이 제대로 작동할 때 큰 성취감을 느꼈고, 프로그래밍은 단순히 코드를 작성하는 것이 아니라 내가 가진 아이디어나 불편함을 실제 결과물로 만들어 낼 수 있는 도구라는 점도 느낄 수 있었다.

앞으로는 현재 만든 Bears Lab에서 경기 예측의 정확도를 높이고 선수 비교 기능이나 AI를 활용한 분석 기능도 추가해 더 발전시켜 보고 싶다. 또한 새로운 기술을 배우는 데서 끝나지 않고 직접 여러 프로젝트에 적용해 보면서 개발 경험과 문제 해결 능력을 계속 키워 나가고 싶다.

Doosan Bears Fan Dashboard - Project Documentation

PitchLab Pro

Mon, 01 Jun 2026 00:00:00 GMT

PitchLab Pro

야구 데이터를 활용하는 프로젝트입니다.

평소 야구를 좋아해서 선수들의 구종이나 구속, 투구 스타일을 비교해 보는 것에 관심이 많았고, 여기서 **‘내가 직접 가상의 투수를 만들고 그 투수의 특징을 분석해 볼 수 있으면 어떨까?’**라는 생각을 하게 되었다. 이 아이디어를 실제 서비스로 구현하기 위해 친구와 함께 **야구 투수 분석 및 시뮬레이션 웹 서비스인 ‘PitchLab Pro’**를 개발했다.

PitchLab Pro에서는 사용자가 투수의 이름, 투구폼, 구종, 구속 등을 직접 설정해 자신만의 가상 투수를 만들 수 있도록 했다. 단순히 입력한 값을 보여주는 것에서 끝내지 않고, 공의 도달 시간과 수직·수평 변화량, 헛스윙 유도 난이도, 제구 난이도 등을 계산해 투수의 특징을 분석하도록 구성했다. 또한 분석된 데이터를 바탕으로 파워 피처, 제구형 투수, 변화구 중심 투수, 밸런스형 투수 등으로 유형을 나누고, 선수의 강점과 약점, 육성 방향 등을 보여주는 스카우트 리포트 기능도 구현했다.

개발은 Python Flask를 기반으로 진행했고, 웹 서버 구축과 데이터 베이스 설계, 데이터 처리와 분석 기능, HTML·CSS·JavaScript를 활용한 화면 구성 등을 구현했다. 특히 투수의 기본 정보뿐만 아니라 구속, 변화량, 난이도, 스트라이크존 좌표와 같은 여러 데이터를 저장할 수 있도록 데이터 모델을 구성했고, 입력된 정보를 바탕으로 결과가 자동으로 계산되어 웹 화면에 표시되도록 연결했다. 스트라이크존 안에서 공의 위치를 시각화하고 스트라이크 여부를 판별하는 기능도 추가하여 단순한 수치 분석보다 실제 야구 데이터 분석에 가까운 느낌을 주고자 했다.

프로젝트를 진행하면서 기능을 한 번 구현하는 것만으로 끝나는 것이 아니라, 사용자가 결과를 얼마나 쉽게 이해할 수 있는지까지 고려해야 한다는 점도 알게 되었다. 팀원과 투수 분석 방식이나 화면 배치, 필요한 기능을 계속 논의하며 수정했고, 그래프와 스트라이크존 시각화 등을 활용해 복잡한 분석 결과도 한눈에 확인할 수 있도록 개선했다.

이 프로젝트를 통해 Flask를 활용한 웹 서비스 개발뿐만 아니라 데이터베이스 설계, 데이터 모델링, 분석 알고리즘 구현과 시각화까지 하나의 서비스 안에서 연결하는 경험을 할 수 있었다. 특히 내가 좋아하는 야구라는 주제를 단순한 관심에서 끝내지 않고 직접 프로그램으로 구현하면서, 데이터가 실제 스포츠 분석에 어떻게 활용될 수 있는지도 배울 수 있었다. 앞으로는 실제 KBO 선수 데이터를 연동하거나 머신러닝을 이용한 승부 예측, 3D 투구 궤적 시각화 등의 기능을 추가하여 더 실제 야구 분석에 가까운 플랫폼으로 발전시켜 보고 싶다.

PitchLab Pro - Project Documentation

IRIS - Python Study · 1차시

Mon, 01 Jun 2026 00:00:00 GMT

1. Python이란?

파이썬(Python)은 문법이 쉽고 읽기 편한 프로그래밍 언어로, 변수·조건문·반복문·함수를 사용하며 인공지능(AI), 웹 개발, 데이터 분석 등 다양한 분야에서 활용된다.

2. 변수

(1) 자료형

자료형은 프로그램에서 데이터를 어떤 형태로 저장하고 처리할지를 구분하는 종류이다. 파이썬은 숫자, 문자, 참/거짓뿐만 아니라 여러 데이터를 묶어 저장하는 자료형까지 다양하게 제공하며, 상황에 맞는 자료형을 선택해 사용할 수 있다.

3. 입출력

(1) 입력

input()

(2) 출력

print()

4. 조건문과 반복문

(1) 조건문

주어진 조건의 참(True)과 거짓(False)을 판단하여 실행할 코드를 선택하는 문법이다. if는 조건이 참일 때 실행되고, elif는 다른 조건을 추가로 확인하며, else는 모든 조건이 거짓일 때 실행된다.

age = 18

if age >= 20:
    print("유료 입장입니다.")

(2) 반복문

같은 작업을 여러 번 실행하는 문법이다. for는 정해진 횟수만큼 반복하고, while은 조건이 참인 동안 반복한다. 또한 break는 반복문을 즉시 종료하고, continue는 현재 반복을 건너뛰고 다음 반복을 수행한다.

for i in range(3):
    print(i)

count = 1

while count  [0, 1, 2, 3, 4]

##### 6. 함수와 라이브러리

(1) 함수(Function)

특정 작업을 수행하는 코드를 하나로 묶은 것으로, 필요할 때 호출하여 반복해서 사용할 수 있다.

```python
def hello():
    print("안녕하세요!")

hello()

(2) 매개변수(Parameter)

함수가 전달받은 값을 저장하는 변수이다.

def hello(name):
    print(name)

hello("IRIS")

(3) 인자(Argument)

함수를 호출할 때 전달하는 실제 값이다.

return은 함수에서 처리한 결과를 호출한 곳으로 돌려주는 역할을 한다.

def add(a, b):
    return a + b

print(add(2, 3))

(4) 라이브러리(Library)

미리 작성된 기능을 모아 놓은 것으로, 필요한 기능을 가져와 사용할 수 있다.

import는 라이브러리 전체를 가져올 때 사용하는 문법이다.
from import는 라이브러리에서 필요한 기능만 가져올 때 사용하는 문법이다.
as는 라이브러리나 모듈의 이름을 짧게 바꿔 사용할 때 사용하는 문법이다.

Original post on Tistory

Creative Idea Competition

Mon, 01 Jun 2026 00:00:00 GMT

창의아이디어경진대회 참가 기록입니다.

IRIS 동아리에서 필수로 참여해야 하는 대회여서 창의아이디어경진대회에 참가하게 되었다. 처음에는 대회를 담당해 주실 선생님을 찾는 과정부터 생각보다 쉽지 않아 여러 선생님께 여쭤보며 담당 선생님을 찾았던 기억이 난다. 본격적으로 아이디어를 정하기 시작하면서는 어떤 아이디어가 실제로 사람들에게 도움이 될 수 있을지 친구와 함께 고민했다.

처음 생각했던 아이디어는 에어마우스를 활용한 마우스 조작 시스템이었다. OTT나 영상을 보면서 손에 음식물이 묻어 마우스를 직접 만지기 어려운 상황에서도 손동작만으로 조작할 수 있고, 손이나 팔을 자유롭게 사용하기 어려운 사람들도 조금 더 편하게 컴퓨터를 사용할 수 있도록 해보자는 생각에서 시작했다. 하지만 담당 선생님께 아이디어에 대한 조언을 받은 뒤 다른 방향도 고민해 보는 것이 좋겠다는 의견을 듣게 되었다.

그래서 두 번째로 생각한 것은 야구장이나 축구장처럼 규모가 큰 스포츠 경기장에서 자신의 좌석을 쉽게 찾을 수 있도록 도와주는 시스템이었다. 좌석에 IoT 기술을 적용하고 스마트폰 앱과 연결하여 특정 좌석을 선택하면 해당 위치에 닉네임이나 표시가 나타나도록 해, 복잡하고 많은 좌석 사이에서도 자신의 자리를 쉽게 찾을 수 있도록 하는 방식이었다. 개인적으로는 실제 경기장에서 겪을 수 있는 불편함을 해결할 수 있다는 점에서 발전시켜 보고 싶은 아이디어였다.

하지만 팀원인 친구는 가방 옆 부분에 지퍼를 추가해 가방을 맨 상태에서 물건을 쉽게 꺼낼 수 있도록 하는 아이디어를 제시했고, 이 과정에서 서로 만들고 싶은 프로젝트에 대한 의견 차이가 생겼다. 주변 친구들에게도 의견을 물어보고 서로의 생각을 이야기해 보았지만 결국 하나의 방향으로 충분히 합의하지 못했고, 프로젝트가 처음 계획했던 만큼 구체적으로 진행되지는 못했다.

결과적으로 아쉬움이 남는 대회였지만, 이번 경험을 통해 좋은 아이디어를 생각해 내는 것만큼 팀원끼리 의견을 조율하고 하나의 목표를 정하는 과정도 중요하다는 것을 느꼈다. 서로의 아이디어가 왜 좋은지, 어떤 문제를 해결하려는 것인지 조금 더 구체적인 기준을 세워 비교하고 충분히 대화했다면 더 좋은 방향으로 발전시킬 수 있었을 것 같다. 다음에 비슷한 팀 프로젝트를 하게 된다면 한 사람의 의견으로 바로 결정하기보다는 팀원 모두가 납득할 수 있는 기준을 정하고 의견을 조율해 최종 아이디어를 선택해 보고 싶다.

IRIS - IoT Study · 3차시

Sun, 03 May 2026 00:00:00 GMT

1.LCD

데이터 출력 가능하고, 사용자의 인터페이로 사용 가능하다.

모니터 같은 것이 없어도 확인 가능하다.

2.온습도센서

온도,습도를 확인 할 수 있는 센서이다.

3.CDS조도센서

센서에 입력되는 밝기에 따라 저항이 변한다. 빛이 밝아지면 저항이 낮아지고, 어두워지면 저항이 높아진다. 풀 다운 저항을 만들어야한다. 저항 커진 상태 → 0

3-1.실습

#include 

#define LIGHTPIN A0      
#define SERVO_PIN 3     

Servo myServo;

void setup() {
  Serial.begin(9600);
  myServo.attach(SERVO_PIN); 
}

void loop() {
  int lightValue = analogRead(LIGHTPIN);
  Serial.print("현재 밝기(조도): ");
  Serial.println(lightValue);

  if (lightValue > 500) {
    myServo.write(90);  
  } else {
    myServo.write(0);  
  }

  delay(500);
}

실습 영상.mp4 2.47MB

4.서브 모터

4-1. 준비하기

프로펠러 조립하기

4-2. 서브 모터란?

일반 DC 모터와 달리 원하는 각도까지 회전한 뒤 그 위치에 멈출 수 있다.
서보모터 내부에는 가변저항이 있어 현재 축의 위치(각도)를 측정한다.
제어 회로가 목표 각도와 현재 각도를 비교하여 모터를 움직이고, 목표 위치에 도달하면 멈춘다.
전압의 크기보다는 PWM신호를 이용해 목표 각도를 지정한다.
디지털 신호는 0과 1만 표현하지만, PWM은 켜져 있는 시간의 비율을 바꿔 다양한 각도 정보를 전달할 수 있다.
서보모터는 일정한 주기로 PWM 신호를 받아 목표 위치를 확인하고, 오차가 발생하면 자동으로 보정할 수 있다.

선의 색	역할
검은색	GND(-)
빨간색	VCC(+)
노란색	PWM 제어 신호

4-3. 일반 DC 모터와의 차이

기능/모터 종류	서브 모터	일반 모터
제어 목표	각도와 위치를 제어한다	속도와 방향을 제어한다
회전 범위	0~180도 (정밀)	0~360도 (무한)
제어 신호	PWM	전압 크기와 PWM
구성	모터,기어,위치센서 (가변저항)	순수 모터 본
피드백 여부	오차가 발생하면 스스로 보정	X

5.조이스틱

조이스틱은 X축,Y축 방향을 측정하는 두 개의 아날로그 가변저항과 누름 동작을 감지하는 하나의 디지털 스위치로 구성되고, 아날로그 값은 0~1023 범위로 측정된다.

Original post on Tistory

IRIS - IoT Study · 2차시

Sat, 02 May 2026 00:00:00 GMT

1. 부저란?

능동부저: 다리의 길이가 다르고 한 가지의 음만 낼 수 있다. 전원만 공급하면 바로 소리가 난다.

수동부저: 다리의 길이가 같으며 주파수 범위 내에서 다양한 소리를 낼 수 있다.

2. 택트스위치

푸시버튼을 눌렀을떄 연결되고, 누르지 않을 때는 연결되지 않아 작동하지 않는다.

Floating 현상: 아무것도 연결되어 있지 않아 전압을 모르는 상태이다.

방지하기 위해서는 풀업 저항이나 풀다운 저항 사용해야한다.

방	PULL UP 저항	PULL DOWN 저항	누가 더 많이 사용?
버튼 눌렀을 때	1	0	PULL UP
버튼 누르지 않았을 때	0	1

풀다운보다는 풀업이 노이즈나 충격에 강하기 때문에 풀업 방식을 더 많이 사용하고, 소프트웨어인 풀업도 가능하기 때문이다.

3. 가변저항

가변저항 실습.mp4 6.46MB

4. 초음파 센서

초음파를 보내서 거리를 측정하는 센서이다.

초음파 센서	아두이노
VCC	5V
Trig	디지털~3
Echo	디지털 2
GND	GND

Original post on Tistory

天下第一 코딩大會 (천하제일코딩대회)

Fri, 01 May 2026 00:00:00 GMT

天下第一 코딩大會

대회에서 맡은 역할과 문제 해결 과정, 결과를 기록합니다.

선린인터넷고등학교에 입학한 뒤 처음으로 참가해 본 대회가 천하제일코딩대회였다. 학교에 들어와 처음 나가는 코딩 대회였던 만큼 시작하기 전부터 긴장도 많이 됐지만, 한편으로는 내가 어느 정도까지 문제를 풀 수 있을지 궁금해서 설레기도 했다.

막상 대회가 시작되고 문제를 보니 생각했던 것보다 훨씬 어려웠다. 평소에 풀어보던 문제들과는 느낌도 달랐고, 제한된 시간 안에 문제를 이해하고 해결 방법까지 떠올려야 하다 보니 마음처럼 쉽게 풀리지 않았다. 결국 많은 문제를 해결하지는 못했고 본선에도 진출하지 못해서 아쉬움이 남았다.

그래도 이번 대회는 결과보다 처음으로 실제 코딩 대회의 분위기를 경험해 봤다는 점에서 의미가 컸던 것 같다. 직접 참가해 보니 내가 아직 부족한 부분이 무엇인지도 알 수 있었고, 앞으로 알고리즘 문제를 더 많이 풀면서 실력을 키워야겠다는 생각도 들었다. 첫 대회라 긴장했던 만큼 기억에도 오래 남을 것 같고, 이번 경험을 바탕으로 꾸준히 준비해서 내년에는 더 좋은 성적을 내고 본선 진출에도 다시 한번 도전해 보고 싶다.

IRIS - IoT Study · 1차시

Fri, 01 May 2026 00:00:00 GMT

1. 아두이노란?

하드웨어 및 소프트웨어를 기반, 오픈소스 마이크로컨트롤러 플랫폼이다.

IoT이다.

종류는 아래 사진처럼 있으며 여기서는 Uno를 사용한다.

2. 기본 부품

2-1. 디지털과 아날로그

디지털은 1 , 0으로 1은 HIGH(켜짐) 0은 LOW(꺼짐)

아두이노에서의 아날로그는 0 ~1023이다.

2-2. 점퍼 케이블

앞이 뾰족한 핀이 수 핀, 없는 핀이 암핀이다. 수 핀이 암핀 쪽에 넣는 형식으로 연결한다.

2-3. 브레드보드(빵판)

같은 줄이 같은 방향으로 전기가 흐른다.

2-4. 저항

전류의 흐름을 방해해서 전압과 전류를 조절하는 역할을 한다.

2-5. LED

전기를 통과시킬 때 빛을 발산하는 반도체의 소자이다.

3. 아두이노 IDE

3-1. 아두이노 IDE

아두이노 IDE 다운로드 (https://www.arduino.cc/en/software/)

앱 실행 후 앱 좌측 상단 Select Boad 클릭 아래 나오는 글 클릭

아두이노 장치 선택, 연결한 포트 선택을 하면 세팅이 완료된다.

3-2. 입력과 출력

입력: 키보드 , 마우스 등..

출력: 모니터 등..

4. 실습 정리

int led1 = 10;
int led2 = 9;
int led3 = 8;
int led4 = 7;
int led5 = 6;
int led6 = 5;

void setup() {

  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
  pinMode(led5, OUTPUT);
  pinMode(led6, OUTPUT);

}

void loop() {

  // 오른쪽
  digitalWrite(led1, HIGH);
  delay(100);
  digitalWrite(led1, LOW);

  digitalWrite(led2, HIGH);
  delay(100);
  digitalWrite(led2, LOW);

  digitalWrite(led3, HIGH);
  delay(100);
  digitalWrite(led3, LOW);

  digitalWrite(led4, HIGH);
  delay(100);
  digitalWrite(led4, LOW);

  digitalWrite(led5, HIGH);
  delay(100);
  digitalWrite(led5, LOW);

  digitalWrite(led6, HIGH);
  delay(100);
  digitalWrite(led6, LOW);

  // 왼쪽
  digitalWrite(led5, HIGH);
  delay(100);
  digitalWrite(led5, LOW);

  digitalWrite(led4, HIGH);
  delay(100);
  digitalWrite(led4, LOW);

  digitalWrite(led3, HIGH);
  delay(100);
  digitalWrite(led3, LOW);

  digitalWrite(led2, HIGH);
  delay(100);
  digitalWrite(led2, LOW);

}

먼저 led 6개를 사용 할 것이기에 led 1~6까지 아두이노에 꽃은 번호를 적어 선언해줍니다.

모든 LED가 OUTPUT 할 수 있도록 세팅 해주고

0.1초 마다 1~6,6~1까지 좌우로 움직이며 불이 켜지도록 코드를 작성해줍니다.

실습 영상.mp4

0.68MB

Original post on Tistory

IRIS - C Language Study · 5차시

Sun, 05 Apr 2026 00:00:00 GMT

1. 구조체란?

C언어의 구조체는 여러 개의 서로 다른 타입의 데이터를 하나로 묶을 수 있는 사용자 정의 자료형이다.

관련된 여러 데이터 하나의 묶음으로 관리할 수 있도록 해주기 때문 복잡한 정보를 효율적으로 다룰 수 있다.

구조체는 관련된 데이터를 묶을 수 있으며, 코드를 깔끔하게 관리하면서 재사용을 할 수 있도록 하며, 확장성을 가지고 있다.

2. 구조체의 구조

typedef struct 구조체 이름

혹은 struct 구조체 이름으로 구성 가능하다.

3. 구조체 예제

#include 
#include 

// 구조체 정의
struct Student {
    char name[20];
    int age;
    float score;
};

int main() {
    struct Student s1;

    // 문자열 복사
    strcpy(s1.name, "Kim");

    s1.age = 20;
    s1.score = 95.5;

    printf("이름: %s\n", s1.name);
    printf("나이: %d\n", s1.age);
    printf("점수: %.1f\n", s1.score);

    return 0;
}

struct 구조체 이름을 통해 구조체를 정의해주었고 , 이름, 나이, 점수를 선언해 둡니다.

int main() 함수에서 Student 구조체를 s1이라고 바꾸어 주고

s1.age 이런 형식으로 변수에 값을 넣어줍니다.

그리고 구조체에 들어간 값을 출력해 줍니다.

Original post on Tistory

IRIS - C Language Study · 4차시

Sat, 04 Apr 2026 00:00:00 GMT

1. 재귀 함수

함수가 자기 자신을 호출하는 함수 즉, 함수가 종료될 때 return 값을 자기 자신에게 하는 함수이다.

꼭 필요한 조건

기저 조건: 더 이상 재귀하지 않을 조건
재귀 호출: 자기 자신을 호출

2. 쓰는 이유?

가독성과 안정성이 올라가고, 코드가 간결해진다. 또한 트리, 분할정복 같은 알고리즘에 적합하다. 하지만 스택 오버플로우가 발생할 수 있어서 반드시 종료조건이 필요하다.

3. 예제

#include 

int hap(int n){
    if(n <= 1){
        return n;
    }
    return n + hap(n-1);
}

int main() {

int n = 0;
scanf("%d",&n);
printf("%d",hap(n));
    return 0;
}

종료 조건 까지 계속 더해준다.

int main()함수에서는 입출력을 담당한다.

Original post on Tistory

IRIS - C Language Study · 3차시

Fri, 03 Apr 2026 00:00:00 GMT

1. 동적할당이란?

프로그램 실행 중에 필요한 만큼 메모리를 빌려 쓰는 것이다.

사용이 끝나면 반납하고 다음에 요구하면 다시 할당 가능하다.

malloc 함수를 사용한다.

장점: 메모리 조절이 자유롭다.

단점: 쓰지 않을 때 free로 해주어야 한다.

2. 쓰는 이유?

메모리는 무한한 자원이 아니어서 한정되어 있고, 1000byte 사이즈의 메모리를 할당해 놓고 실제로 더 낮은 btye를 사용하게 되면 비효율적이기 때문이다.

3. 예제

#include 
#include 

int main() {

int cnt = 0;

char *arr = malloc(1001 * sizeof(char));
scanf("%s",arr);

for(int i = 0;arr[i] != '\0';i++){
    if(arr[i] == 'A' || arr[i] == 'a' 
    || arr[i] == 'E' || arr[i] == 'e'
    || arr[i] == 'I' || arr[i] == 'i'
    || arr[i] == 'O'|| arr[i] == 'o'
    || arr[i] == 'U'|| arr[i] == 'u')
        cnt +=1;
}

printf("%d",cnt);
free(arr);
    return 0;
}

malloc을 사용해 데이터 크기를 정해주고 있다.

Original post on Tistory

IRIS - C Language Study · 2차시

Thu, 02 Apr 2026 00:00:00 GMT

1. 포인터란?

포인터는 메모리에 저장된 데이터의 위치(주소)를 값으로 가지는 변수이다.

포인터는 * 기호로 선언하며, & 연산자를 사용해 변수의 주소를 얻는다.

2. 포인터의 구조

출처:https://www.memoengine.com/blog/c-language-pointer-variable/

p의 값을 출력하면 주소값인 1234가 출력될 것이고, *p의 값을 출력하면 1234번지 속의 값인 Z가 출력될 것입니다.

3-1. 예제

#include 

int main() {
    int a = 5;
    int *p = &a;   

    printf("a의 값: %d\n", a);
    printf("a의 주소: %p\n", &a);
    printf("p의 값(주소): %p\n", p);
    printf("p가 가리키는 값: %d\n", *p);

    return 0;
}

일단 a의 값을 지정해 주고, int *p;로 포인터를 선언해 줍니다.

int *p = &a;를 통해 a의 주소를 p에 저장합니다.

printf("a의 값: %d\n", a); 여기서는 그냥 a의 값이 출력될 것입니다. (5)

printf("a의 주소: %p\n", &a); 여기서는 a의 주소 값이 출력될 것입니다. (주소가 만약에 1234라고 가정하면 1234 출력)

printf("p의 값(주소): %p\n", p); 여기서는 p의 값이 출력되는데, 포인터가 아닌 그냥 p는 주소가 출력됩니다. ( 주소가 만약에 1234라고 가정하면 1234 출력)

printf("p가 가리키는 값: %d\n", *p); 여기서는 *p를 출력하기 때문의 a의 주소에 저장된 값을 출력할 것입니다. (5)

3-2. 예제

#include 

void change(int *x);   // 함수 선언

int main() {
    int a = 5;

    printf("변경 전: %d\n", a);

    change(&a);   // a의 주소 전달

    printf("변경 후: %d\n", a);

    return 0;
}

void change(int *x) {
    *x = 10;   // a의 값을 직접 변경
}

일단 int a = 5;를 통해 변수 a의 값을 5로 지정해 줍니다.

그리고 change(&a);를 통해 a의 주소를 함수로 전달합니다.

함수 선언 부분인 void change(int *x);에서 알 수 있듯이, 함수는 주소를 받기 위해 포인터 매개변수 x를 사용합니다.

이후 change 함수가 실행되면, 전달받은 a의 주소가 x에 저장됩니다.

함수 내부에서 *x = 10;을 수행하게 되는데, 이는 x가 가리키는 주소에 있는 값을 10으로 변경하는 것이므로, 결국 a의 값이 10으로 바뀌게 됩니다.

따라서 함수 실행이 끝난 후 printf("변경 후: %d\n", a);에서 a의 값이 10으로 출력됩니다.

Original post on Tistory

IRIS - C Language Study · 1차시

Wed, 01 Apr 2026 00:00:00 GMT

1. 함수란?

특정한 기능을 수행하도록 설계된 재사용 가능한 코드의 집합

출처:https://sejong-kr.libguides.com/c.php?g=942233&p=6822325https://sejong-kr.libguides.com/c.php?g=942233&p=6822325

2. 함수의 구조

출처:https://sejong-kr.libguides.com/c.php?g=942233&p=6822325https://sejong-kr.libguides.com/c.php?g=942233&p=6822325

형식을 보면 이렇습니다.

출처:https://sejong-kr.libguides.com/c.php?g=942233&p=6822325https://sejong-kr.libguides.com/c.php?g=942233&p=6822325

반환형을 정해 주고, 함수이름을 정해주며, 매개 변수를 선언해 줍니다.

여기서 매개변수란?

함수가 작업을 수행하는데 필요한 데이터를 받아들이는 함수의 입력 인자입니다.

3. 함수의 반환

return 문을 통해 함수 호출부로 데이터를 전달하는 값.

반환형을 정하고 return 뒤에 값을 지정한다.(a+b.. 등),

void는 반환이 없음을 의미한다.

4. 예제

#include 

int sum(int a, int b);    // sum 함수 선언

int main()
{
    int x = 3, y = 4;
    int result;

    result = sum(x, y);    // sum 함수 호출
    printf("result는 %d입니다.\n", result);

    return 0;
}

int sum(int a, int b)    // sum 함수 정의
{
    int hap;

    hap = a + b;

    return hap;
}

먼저 int sum(int a, int b);를 통해 sum 함수를 선언해 줍니다.

그리고 int main() 함수 안에서 x, y의 값을 3,4로 지정해 줍니다.

그리고 result의 값이 sum(x, y);라고 sum 함수를 호출합니다.

다시 아래로 가 hap = a+b;이고 return hap;을 해주었기 때문에

위 printf("result = %d입니다.", result); 에서 7의 값이 출력될 것입니다.

Original post on Tistory

IRIS 2nd Member

Wed, 01 Apr 2026 00:00:00 GMT

IRIS 2기 구성원으로 프로젝트와 학습 활동을 진행하고 있습니다.

선린인터넷고등학교 정보보호과에 입학한 뒤, 내가 고등학교 생활에서 가장 해보고 싶었던 것 중 하나는 단순히 프로그래밍을 공부하는 데서 끝나는 것이 아니라, 내가 배운 기술을 직접 사용해서 실제로 작동하는 무언가를 만들어 보는 것이었다. 중학교 때까지는 대부분 혼자 강의를 보거나 문제를 풀면서 프로그래밍을 공부했기 때문에, 고등학교에서는 다른 사람들과 함께 아이디어를 내고 프로젝트를 만들어 보는 경험을 꼭 해보고 싶었다.

나는 동두천 교육지원청에서 AI 챌린지 수업을 들으면서 AI에 대한 관심을 가지게 되었고, 추가로 내 관심사인 무기와 AI를 융합한 AI 무기체계 개발 연구원이 되고 싶다는 꿈을 꾸게 되었다. 그리고 IoT에 대한 지식도 무기체계 개발에 도움이 될 것 같아 관심이 갔다. 그런 점에서 AI & IoT 동아리인 IRIS는 내가 관심을 가지고 있던 분야와 가장 잘 맞는 동아리라고 생각했다.

내가 처음 프로그래밍에 관심을 가지게 된 계기는 초등학교 때 접한 로블록스였다. 게임을 하다 보니 자연스럽게 “이건 어떻게 만들어졌을까?”라는 궁금증이 생겼고, 중학생부터 개발이라는 분야에 관심을 가지기 시작했다. 이후 프로그래밍 언어라는 것이 있다는 것을 알게 되었고, 유튜브의 ‘나도코딩’ 강의를 보면서 파이썬을 처음 공부했다. 처음에는 변수, 조건문, 반복문 같은 기본적인 문법을 배우는 것만으로도 재미있었지만, 점점 단순히 강의를 따라 치는 것보다 내가 직접 문제를 해결하고 프로그램을 만들어 보는 과정이 더 흥미롭게 느껴졌다.

그래서 백준과 코드업에서 알고리즘 문제를 풀면서 논리적으로 생각하는 연습을 했고, Cos Pro 3급 자격증도 취득하며 기본적인 프로그래밍 실력을 확인해 볼 수 있었다. 하지만 문제를 푸는 것만으로는 조금 아쉬웠다. 실제 서비스나 프로그램은 알고리즘 문제처럼 정해진 입력과 출력만 있는 것이 아니고, 여러 기술이 함께 연결되어 하나의 결과물이 만들어지기 때문이다. 그래서 직접 프로그램을 하나 만들어 보고 싶다는 생각으로 ‘Supernova’라는 채팅 앱을 개발하게 됐다.

Supernova를 만들면서 처음에는 단순히 메시지를 보내고 받는 기능을 구현하면 될 것이라고 생각했다. 하지만 개발을 시작하고 보니 생각보다 알아야 할 것이 많았다. 사용자가 입력한 메시지가 어떤 방식으로 서버에 전달되는지, 서버는 그것을 어떻게 처리하는지, 다시 다른 사용자에게 어떤 방식으로 전달되는지 등을 이해해야 했다. 그 과정에서 자연스럽게 네트워크 통신, HTTP 프로토콜, 웹 서버의 동작 방식을 찾아보며 공부하게 됐다. 오류가 발생했을 때도 단순히 코드를 다시 작성하기보다는 어디에서 문제가 생겼는지 하나씩 확인하고 원인을 찾으려고 했다.

이 경험을 통해 내가 가장 크게 느낀 것은 개발은 직접 만들어 봐야 제대로 배울 수 있다는 점이었다. 강의나 책으로 볼 때는 이해했다고 생각했던 내용도 실제로 구현하려고 하면 생각대로 동작하지 않는 경우가 많았다. 반대로 처음에는 전혀 몰랐던 내용도 필요해서 찾아보고, 직접 적용하고, 오류를 고치다 보면 어느 순간 자연스럽게 이해되는 경우도 있었다. 그래서 이후에는 새로운 기술을 배울 때도 “이걸 어디에 사용할 수 있을까?”, “직접 만들어 본다면 어떤 식으로 구현할 수 있을까?”를 생각하게 됐다.

IRIS에 관심을 가지게 된 결정적인 계기는 선린인터넷고 소프트웨어 나눔 축제에서 참여했던 IoT 정찰병 프로그램이었다. 당시 프로그램에 참여하면서 라즈베리파이가 센서나 여러 장치를 제어하고, 데이터를 처리하는 중심 역할을 할 수 있다는 것을 배웠다. 이전까지 IoT라는 단어는 많이 들어봤지만 실제로 어떤 장치들이 연결되고 어떤 원리로 동작하는지는 잘 알지 못했다. 그런데 직접 장치를 보고 원리를 설명받으며 체험해 보니 IoT라는 기술이 훨씬 구체적으로 느껴졌다.

특히 인상 깊었던 점은 컴퓨터 안에서만 동작하던 코드가 실제 현실의 장치를 움직일 수 있다는 것이었다. 내가 그동안 작성했던 프로그램들은 대부분 화면 안에서 결과를 출력하거나 데이터를 처리하는 형태였다. 하지만 IoT에서는 센서가 주변 환경의 정보를 받아들이고, 프로그램이 그 데이터를 판단한 뒤 실제 장치를 동작시킬 수 있었다. 이 과정을 보면서 소프트웨어가 현실 세계와 직접 연결될 수 있다는 점이 굉장히 흥미롭게 느껴졌다.

그리고 기술만큼이나 기억에 남았던 것은 IRIS 선배들의 분위기와 설명 방식이었다. 단순히 결과만 보여주는 것이 아니라 왜 그렇게 동작하는지 원리를 설명해 주고, 직접 해볼 수 있도록 도와주는 모습이 인상적이었다. 모르는 것을 질문하기 어렵지 않은 분위기였고, 서로 아이디어를 이야기하면서 프로그램을 진행하는 모습도 재미있어 보였다. 그때부터 “나도 고등학교에 입학하면 이런 동아리에서 활동해 보고 싶다”는 생각을 하게 됐다.

나는 IRIS에서 특히 AI와 IoT를 따로 배우는 것이 아니라 서로 연결해서 활용해 보고 싶다. 예를 들어 센서가 주변 환경의 온도나 움직임, 거리 같은 정보를 수집하고, 프로그램이 그 데이터를 처리한 뒤 AI가 상황을 판단해서 장치를 작동시키는 시스템을 만들어 보고 싶다. 아직은 구체적으로 어떤 프로젝트를 만들게 될지는 모르지만, 단순히 기능 하나만 구현하는 것이 아니라 여러 기술을 연결해서 하나의 완성된 시스템을 만들어 보는 경험을 해보고 싶다.

예를 들어 주변 환경을 감지해 위험 상황이나 특정 변화를 알려주는 IoT 장치, 카메라나 센서 데이터를 분석해 상황을 판단하는 시스템, 특정 조건에 따라 자동으로 동작하는 장치 같은 프로젝트도 만들어 보고 싶다. 이런 프로젝트를 직접 진행하다 보면 프로그래밍뿐 아니라 하드웨어 제어, 네트워크 통신, 데이터 처리, AI 모델 활용 등 여러 분야를 자연스럽게 함께 공부하게 될 것이라고 생각한다.

무엇보다 IRIS에서는 혼자 개발하는 것과는 다른 협업 경험도 많이 해보고 싶다. 혼자 프로젝트를 하면 내가 원하는 방식으로 빠르게 결정할 수 있다는 장점이 있지만, 내가 생각하지 못한 부분을 발견하기 어렵다는 단점도 있다. 반대로 여러 사람이 함께 프로젝트를 진행하면 서로 다른 아이디어가 나오고, 한 사람이 잘 모르는 부분을 다른 사람이 해결해 줄 수도 있다. 물론 의견이 맞지 않거나 역할을 나누는 과정에서 어려움이 생길 수도 있겠지만, 그런 과정까지 포함해서 실제 개발 프로젝트에서 중요한 경험이라고 생각한다.

물론 지금의 나는 AI나 IoT에 대해 깊은 지식을 가지고 있는 것은 아니다. 라즈베리파이나 센서를 자유롭게 다룰 수 있는 것도 아니고, AI 모델을 처음부터 직접 설계할 수 있는 수준도 아니다. 하지만 나는 모르는 기술이 나오면 직접 찾아보고, 오류가 발생하면 원인을 하나씩 확인하면서 해결해 나가는 과정 자체를 좋아한다. 처음부터 모든 것을 알고 있는 것보다 새로운 기술을 만나고, 시행착오를 겪으면서 점점 할 수 있는 것이 많아지는 과정이 개발의 재미라고 생각한다.

그래서 IRIS에 들어가게 된다면 내가 이미 알고 있는 것을 보여주는 것보다 얼마나 많이 배우고, 얼마나 많이 직접 시도해 볼 수 있는지가 더 기대된다. 선배들에게 모르는 것을 배우고, 친구들과 아이디어를 나누고, 내가 알고 있는 부분이 있다면 다른 사람에게도 공유하면서 같이 성장하고 싶다. 프로젝트에서 내가 맡은 역할은 끝까지 책임지고, 필요하다면 처음 접하는 기술이라도 직접 공부해서 팀에 도움이 되는 사람이 되고 싶다.

장기적으로 나는 AI 기술을 활용하는 개발자가 되고 싶다. 특히 관심을 가지고 있는 분야 중 하나는 방산 분야에서 AI가 융합된 시스템을 개발하는 것이다. 미래의 무기체계나 국방 시스템에서는 단순히 하드웨어 성능만 중요한 것이 아니라, 센서에서 들어오는 많은 데이터를 빠르게 처리하고 상황을 판단하는 AI 기술도 점점 중요해질 것이라고 생각한다. 아직 학생인 내가 구체적으로 어떤 일을 하게 될지는 알 수 없지만, AI와 IoT처럼 소프트웨어와 실제 장치가 연결되는 기술을 경험하는 것은 앞으로 내가 하고 싶은 분야와도 분명 연결되어 있다고 생각한다.

그런 의미에서 나에게 IRIS는 단순히 학교생활을 위해 선택하는 동아리가 아니다. 지금까지 혼자 공부해 왔던 프로그래밍을 실제 프로젝트, 하드웨어, AI, 그리고 협업으로 확장해 볼 수 있는 기회라고 생각한다. 지금까지는 대부분 내가 필요하다고 생각한 것을 혼자 찾아 공부했다면, IRIS에서는 나보다 먼저 다양한 경험을 해본 선배들과 같은 관심사를 가진 친구들에게 배우면서 더 넓은 시야를 가질 수 있을 것 같다.

그리고 개인적으로는 결과물만큼이나 그 과정도 중요하게 남았으면 좋겠다. 프로젝트를 처음 기획할 때 어떤 아이디어를 냈는지, 개발하면서 어떤 문제가 발생했는지, 팀원들과 어떻게 해결했는지, 완성한 뒤에는 무엇이 아쉬웠는지까지 기록해 두고 싶다. 그렇게 하나씩 경험을 쌓다 보면 나중에는 단순히 “이 기술을 배웠다”가 아니라 **“이 문제를 해결하기 위해 이 기술을 사용했고, 실제로 이런 결과물을 만들었다”**고 말할 수 있을 것 같다.

고등학교 생활이 끝났을 때 나는 단순히 **“IRIS라는 동아리에서 활동했다”**고 기억하고 싶지는 않다. 대신 **“IRIS에서 이런 프로젝트를 만들었고, 이 문제 때문에 며칠 동안 고민했고, 결국 팀원들과 해결했고, 그 과정에서 이런 기술을 배웠다”**고 말할 수 있었으면 좋겠다.

아직 배워야 할 것은 정말 많지만, 그렇기 때문에 오히려 더 기대된다. IRIS에서 많이 배우고, 많이 실패해 보고, 많이 만들어 보면서 지금보다 훨씬 성장한 개발자가 되고 싶다. 그리고 몇 년 뒤 지금 이 글을 다시 봤을 때, 여기 적어 둔 것들을 실제로 하나씩 해냈다고 말할 수 있었으면 좋겠다.

Sunrin Internet High School 121th

Sun, 01 Mar 2026 00:00:00 GMT

선린 입학을 준비했던 시기는 내가 진로에 대해서 가장 많이 생각했던 시기 중 하나였던 것 같다.

처음에는 로블록스 개발이 재미있어서 공부를 하고 싶어졌고 학교를 알아보다가 그냥 정보보호과에 들어가고 싶다는 생각으로 시작했다. 그런데 입학을 준비하면서 단순히 원서를 넣고 면접을 준비하는 것에서 끝나는 게 아니라, 내가 왜 이 분야를 선택했는지, 앞으로 뭘 하고 싶은지, 지금까지 뭘 해왔는지 계속 생각하게 됐다.

공부

선린 입학 준비를 하면서 파이썬, 네트워크, 정보보안 관련 개념들을 공부했다.

파이썬에서는 변수나 조건문, 반복문 같은 기본적인 문법부터 리스트, 튜플, 딕셔너리, 함수 등을 공부했고, 별 찍기나 소수 찾기 같은 백준,Code Up문제도 풀었다. 처음에는 코드를 그냥 따라 치거나 문법을 외우는 경우도 많았는데, 문제를 풀면서 조금씩 어떤 상황에서 어떤 문법을 사용해야 하는지 생각하게 됐다. 그리고 Cos pro 3급 자격증도 취득 했다.

네트워크 쪽도 꽤 많이 공부했다. OSI 7계층이나 TCP/IP, HTTP, DNS, IP 주소, 포트, 패킷 같은 개념들을 공부하면서 처음에는 각각 따로 외웠다. 그런데 나중에는 사용자가 URL을 입력하고 웹사이트가 화면에 나타나기까지의 과정을 연결해서 이해하려고 했다.

정보보안에서는 암호화, 방화벽, 프로토콜 같은 기본적인 개념을 공부고 해킹에 공격 기술 이론도 간단히 공부 했다. 특히 단순히 개념을 외우는 것보다 이 기술이 실제로 어디에서 사용되고 왜 필요한지 같이 생각하려고 했던 것 같다.

자소서

자소서를 쓰는 과정도 기억에 많이 남는다.

처음에는 내가 했던 활동들을 그냥 나열하면 되는 줄 알았다. 그런데 계속 수정하다 보니까 중요한 건 무엇을 했는지보다 왜 했고, 그 과정에서 뭘 느끼고 배웠는지라는 걸 알게 됐다.

내가 했던 봉사활동이나 공부, 프로젝트 같은 경험들을 다시 하나씩 돌아봤다. 당시에는 그냥 했던 일이라고 생각했던 것들도 자소서를 쓰면서 다시 생각해 보니 나름대로 이유와 과정이 있었다.

그래서 자소서를 준비하면서 단순히 글을 쓰는 것뿐만 아니라, 지금까지 내가 어떤 경험을 해왔는지 정리하는 시간을 가졌던 것 같다.

면접

면접 준비하면서는 하루 종일 면접 예상 질문에 답을 달 정도로 예상 질문에 대한 답변을 정말 많이 생각했다.

왜 정보보호과에 지원했는지, 정보보안에서 가장 중요하다고 생각하는 것이 무엇인지, 개발자나 정보보안 전문가가 되기 위해 어떤 노력을 했는지 같은 질문들에 답하면서 내가 생각보다 명확하게 설명하지 못하는 부분도 발견했다.

그래서 그냥 답변을 외우기보다는 내가 공부했던 내용이나 실제 경험을 바탕으로 이야기하려고 했다.

면접 준비를 하면서 느낀 건 내가 알고 있다고 생각하는 것과 다른 사람에게 설명할 수 있는 것은 다르다는 것이었다. 그래서 어려운 개념도 최대한 내가 이해한 방식으로 설명할 수 있도록 정리하고 연습했다.

프로젝트와 만들고 싶었던 것들

입학 준비를 하면서 프로젝트에 대한 생각도 많이 했다.

단순히 공부만 하는 것보다 직접 뭔가 만들어보는 것에 관심이 있었고, 디스코드 같은 채팅 앱을 만들어보고 싶다는 생각도 했다. 앱의 이름을 고민하기도 하고, 어떤 기능이 있으면 좋을지 생각하면서 Supernova라는 이름도 떠올렸다.

당장 완성된 프로젝트만 중요한 게 아니라, 내가 어떤 서비스를 만들고 싶은지 생각하고 직접 구현할 방법을 고민하는 과정 자체도 재미있었다.

또 여러 프로젝트와 기술을 보면서 내가 단순히 코드를 작성하는 것뿐만 아니라, 나중에는 실제로 사람들이 사용할 수 있는 프로그램이나 서비스를 만들어보고 싶다는 생각도 하게 됐다.

프로젝트를 준비하면서 flask와 웹 소켓에 대해 공부했다. 처음에는 소켓을 사용해서 실시간 채팅을 구현 할려고 했는데, 그 과정속에 어려움을 겪어서 롱폴링을 공부해 구현했다.

준비하면서 느낀 점

지금 돌아보면 선린 입학 준비는 단순히 고등학교 입학을 준비했던 기간이라기보다는, 내가 개발과 정보보안 분야를 본격적으로 알아가기 시작했던 시기였던 것 같다.

처음에는 면접을 위해서 공부했던 개념들도 많았지만, 공부하다 보면 궁금한 게 계속 생겼다.

패킷은 정확히 뭐지? TCP는 왜 신뢰성이 있다고 하는 거지? DNS는 실제로 어떻게 동작하지? 암호화는 그냥 글자를 이상하게 바꾸는 것과 뭐가 다르지?

이런 식으로 하나를 공부하면 또 다른 궁금증이 생겼고, 그걸 찾아보면서 공부하는 범위가 점점 넓어졌다.

자소서를 쓰면서는 내가 지금까지 했던 경험을 정리했고, 면접을 준비하면서는 내가 왜 이 분야에 관심이 있는지 생각했고, 프로젝트를 고민하면서는 앞으로 내가 직접 만들어보고 싶은 것들에 대해서 생각했다.

그래서 선린 입학 준비는 나한테 단순히 합격하기 위해 준비했던 과정이라기보다는,

내가 지금까지 뭘 해왔는지 돌아보고 내가 뭘 좋아하는지 생각하고 앞으로 어떤 걸 만들어보고 싶은지 처음으로 진지하게 고민했던 시기였던 것 같다.

지금 이 포트폴리오에 당시 자료들을 다시 정리하는 이유도 단순히 결과물을 남기기 위해서만은 아니다.

그때 작성했던 자소서, 공부했던 내용, 준비했던 면접 답변, 생각했던 프로젝트들을 다시 보면 내가 처음 이 분야에 관심을 가지기 시작했을 때 어떤 생각을 했는지 볼 수 있을 것 같다.

완벽했던 과정은 아니었지만, 지금의 내가 있기까지 꽤 중요한 시작점이었다고 생각한다.

Web Chatting Service - Supernova

Sat, 01 Nov 2025 00:00:00 GMT

Supernova

웹 기반 채팅 서비스를 개발한 프로젝트입니다.

역할: Developer
분야: Web Development
사용 기술: python , flask , 롱폴링
내용: Supernova는 내가 직접 채팅 애플리케이션을 만들어보고 싶다는 생각에서 시작한 프로젝트다.

처음에는 디스코드처럼 여러 사람이 실시간으로 대화할 수 있는 프로그램을 만들어보고 싶었다. 단순히 메시지를 주고받는 기능만 있는 것이 아니라, 사용자들이 하나의 공간에 들어와서 대화하고 서로 소통할 수 있는 서비스를 직접 만들어보고 싶었다.

프로젝트를 생각하면서 가장 먼저 고민했던 것 중 하나는 이름이었다. 여러 이름을 생각하다가 Supernova라는 이름을 떠올렸다. 초신성이라는 단어가 주는 강렬한 느낌이 마음에 들었고, 내가 처음부터 직접 만들어가는 프로젝트에 잘 어울린다고 생각했다.

처음에는 단순히 "채팅 프로그램 하나 만들어보자" 정도의 생각이었지만, 프로젝트를 구체적으로 생각할수록 고민해야 할 것들이 생각보다 많았다.

사용자는 어떻게 가입할지, 친구나 다른 사용자는 어떻게 추가할지, 메시지는 어떤 방식으로 전달할지, 여러 사람이 동시에 대화할 수 있는 기능은 어떻게 만들지 등 단순히 화면을 만드는 것 외에도 생각해야 할 부분이 많았다.

특히 채팅 기능을 생각하면서 자연스럽게 실시간 통신에도 관심을 가지게 됐다. 사용자가 메시지를 보내면 상대방에게 바로 전달되기 위해서는 어떤 방식으로 서버와 통신해야 하는지 궁금했고, 이 과정에서 HTTP, 롱폴링, 소켓 같은 네트워크 기술에 대해서도 찾아보게 됐다.

프로젝트 하나를 만들기 위해서 단순히 프로그래밍 언어만 공부하면 되는 것이 아니라, 네트워크와 서버, 데이터 관리처럼 여러 기술이 함께 사용된다는 것도 알게 됐다.

Supernova는 처음부터 완벽하게 계획된 프로젝트는 아니었다. 오히려 "이런 걸 만들어보고 싶다"는 생각에서 시작해서, 필요한 기능을 하나씩 생각하고 그 기능을 구현하기 위해 어떤 기술이 필요한지 찾아보는 과정에 가까웠다.

하지만 이 프로젝트를 생각하고 준비하면서 내가 단순히 코드를 공부하는 것보다 직접 서비스를 만드는 것에 더 큰 흥미를 느낀다는 것을 알게 됐다.

하나의 기능을 만들기 위해 필요한 기술을 찾아보고, 문제가 생기면 원인을 생각하고, 조금씩 내가 생각했던 모습을 만들어가는 과정이 재미있었다.

Supernova는 나에게 단순한 채팅 앱 프로젝트가 아니었다.

내가 처음으로 **"이런 서비스를 직접 만들어보고 싶다"**고 구체적으로 생각했던 프로젝트였고, 개발을 공부하는 이유를 조금 더 명확하게 만들어준 프로젝트이기도 하다.

완성된 결과물도 중요하지만, 지금 다시 생각해 보면 이 프로젝트를 통해 가장 크게 얻은 것은 직접 무언가를 만들기 위해 고민했던 경험인 것 같다.

아이디어 하나에서 시작해서 이름을 정하고, 필요한 기능을 생각하고, 그 기능을 만들기 위해 어떤 기술을 공부해야 하는지 찾아봤던 과정 자체가 나에게는 의미 있었다.

Supernova는 그렇게 내가 개발이라는 분야를 단순히 공부하는 것에서 조금 더 나아가, 내가 생각한 것을 직접 만들어보고 싶다는 목표를 가지게 된 시작점 중 하나로 기억하고 싶다.

Supernova - Project Archive

Flask Study · 2차시

Tue, 02 Sep 2025 00:00:00 GMT

안녕하세요. 오늘은 Jinja2 + HTML 렌더링에 대해 알아보겠습니다. !파이썬(py)은 이미 깔려 있다는 가정 하에 진행합니다!

I. Jinja2란?

Jinja2는 Python 기반의 템플릿 엔진 웹 개발에서 HTML 파일을 동적으로 생성할 때 주로 사용됩니다. Flask, Django 등 Python 웹 프레임워크와 함께 자주 쓰임.

Jinja2 가 무엇인지 알아보았기 때문에, 이제 Jinja2 + HTML 렌더링을 시작해 보도록 하자.

II. Jinja + HTML

1. 구조

flask + HTML 기본 구조

2. Flask

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def home():
    name = "Flask"    #name을 정의                 
    items = ["사과", "바나나", "체리"] #items를 정의     
    return render_template("index.html", name=name, items=items) # html로 정의 된 것을 넘김 

if __name__ == '__main__':
    app.run(debug=True)

flask 예시 코드

3. HTML + Jinja2


Flask + Jinja2 예시

## 안녕하세요, {{ name }}님!

 #넘어 온 name 출력

### 오늘의 과일 목록:

{% for item in items %} #아이템 목록에서

- {{ item }} #넘어온 아이템들 출력
{% endfor %}

{% if "체리" in items %} #만약 체리가 아이템들 안에 있다면

오늘은 체리가 포함되어 있습니다

 #출력
{% else %} #아니면

오늘 체리는 없네요

 #출력
{% endif %}

HTML + Jinja2 예시 코드

4. 렌더링

HTML + Jinja2 렌더링

만약에 리스트 안에 체리가 없었다면 '오늘 체리는 없네요' 문장이 출력 되었겠죠?

III. 마무리

이상으로 Jinja2 + HTML 렌더링에 대해 마칩니다.

Original post on Tistory

Flask Study · 1차시

Mon, 01 Sep 2025 00:00:00 GMT

안녕하세요. 오늘은 Flask 기초와 HTML 렌더링 방법에 대해 알아보겠습니다. !파이썬(py)은 이미 깔려 있다는 가정 하에 진행합니다!

I. Flask란?

Flask란 Python으로 웹사이트나 웹 애플리케이션을 만들 수 있게 해주는 웹 프레임워크 간단히 말해, Flask는 “Python으로 웹사이트를 만들 수 있게 도와주는 도구”라고 할 수 있다.

Flask가 무엇인지 알아보았기 때문에, 이제 Flask를 시작해 보도록 하자.

II. Flask 시작하기

1.Flask 설치하기

flask 를 설치하는 사진

pip install flask 명령어를 터미널에 입력하여 Flask를 설치한다.

app.py 만들기

(1) VSC( Visual Studio Code)를 열어 자신의 파일로 연다 (2) app.py 파일을 만든다.

app.py 만들기

표시된 빨간 부분을 누르고 app.py를 만든다.

app.py 가 만들어진 모습

3.Flask 예시 코드 작성하기

Flask 기본 예시 코드

화면과 같이 코드를 작성해 준다.

Flask 서버 열기 Flask를 실행하기 위해 터미널에 flask run을 입력한다.

Flask 서버가 열린 모습

CTRL + C를 눌러 서버를 닫을 수 있다.

이처럼 Flask의 기본에 대해 알아보았다. 이제, 'Flask를 이용한 HTML 렌더링 하기'로 넘어가 보도록 하자.

III. Flask를 이용한 HTML 렌더링 하기

Flask + HTML 예시 작성하기

Flask + HTML의 기본 예시 코드

화면과 같이 코드를 작성해 준다.

index.html에 'START FLASK'를 띄우기 위해 HTML에 이렇게 작성한다.

HTML

화면과 같이 코드를 작성해 준다.

flask run 명령어를 터미널에 입력하여, Flask 서버를 연다.

flask 서버를 열린 모습

CTRL + C를 눌러 서버를 닫을 수 있다.

Running on http://127.0.0.1:5000을 누르거나 직접 입력하여 접속하면,

HTML 화면의 글씨

아까 HTML에서 작성한 'START FLASK'라는 문구가 화면에 렌더링 된다.

IV. 마무리

이상으로 Flask 시작과 Flask를 이용한 HTML 렌더링에 대해 마친다.

Original post on Tistory