rwg5565 님의 블로그

2024-10-18 딥러닝

rwg5565 — Fri, 18 Oct 2024 11:16:04 +0900

1. 어텐션 메커니즘의 개념

어텐션 메커니즘은 입력 데이터에서 중요한 정보에 가중치를 부여하는 방식입니다. 예를 들어, 문장을 번역할 때 한 단어가 다른 단어보다 더 중요한 경우가 있습니다. 이런 상황에서 모든 단어를 동일하게 처리하지 않고, 중요한 단어에 가중치를 더 부여하는 것이 어텐션입니다.

2. 어텐션 메커니즘의 원리

어텐션은 쿼리(Query), 키(Key), 값(Value) 세 가지 개념을 사용합니다.

쿼리(Query): 현재 단계에서 참고할 정보
키(Key): 입력 데이터의 각 요소를 구별하기 위한 식별자
값(Value): 키와 쿼리의 유사도를 기반으로 반환할 데이터

Transformer와 어텐션

Transformer는 **셀프 어텐션(Self-Attention)**을 기반으로 한 모델로, BERT, GPT와 같은 모델들이 Transformer 구조를 따릅니다.

1) 멀티 헤드 어텐션 (Multi-Head Attention)

여러 개의 어텐션 헤드를 사용해 서로 다른 부분에 집중합니다.
다양한 정보의 패턴을 더 잘 포착할 수 있습니다.

2) 포지셔널 인코딩 (Positional Encoding)

어텐션 메커니즘 자체는 순서 정보를 고려하지 않으므로, 순서 정보를 추가하기 위해 포지셔널 인코딩을 사용합니다.

즉 GPT는 우리가 질문을 하면 맥락을 잡을 수 있다는 말이죠

어텐션 메커니즘은 AI 모델의 정밀도를 높이는 강력한 도구입니다. 특히 Transformer와 같은 구조를 통해 자연어 처리와 컴퓨터 비전 분야에서 큰 성과를 이루었으며, 앞으로도 다양한 분야에 활용될 가능성이 큽니다.

이 코드는 입력 3개의 단어가 들어오면 각 단어에 대해 어텐션 스코어, 즉 가중치 뭐가 더 중요한지 계산하고 가중합 벡터를 생성하는 코드 입니다.(GPT가 말을 두서 없이 해도 알아먹는 이유)

import numpy as np

# 1. 입력 벡터 (3개의 단어, 4차원 임베딩)
inputs = np.array([
    [1, 0, 1, 0],  # 단어 1
    [0, 2, 0, 2],  # 단어 2
    [1, 1, 1, 1]   # 단어 3
])

# 2. Query, Key, Value 가중치 행렬 초기화 (4차원 -> 4차원 매핑)
W_q = np.random.rand(4, 4)
W_k = np.random.rand(4, 4)
W_v = np.random.rand(4, 4)

# 3. Query, Key, Value 계산
queries = np.dot(inputs, W_q)  # (3x4) * (4x4) = (3x4)
keys = np.dot(inputs, W_k)      # (3x4) * (4x4) = (3x4)
values = np.dot(inputs, W_v)    # (3x4) * (4x4) = (3x4)

# 4. 어텐션 스코어 계산 (쿼리와 키의 점곱)
attention_scores = np.dot(queries, keys.T)  # (3x4) * (4x3) = (3x3)

# 5. 스코어 정규화 (Softmax 함수)
def softmax(x):
    exp_x = np.exp(x - np.max(x))
    return exp_x / exp_x.sum(axis=-1, keepdims=True)

attention_weights = softmax(attention_scores)  # (3x3)

# 6. 가중합 계산 (어텐션 가중치 * Value)
weighted_sum = np.dot(attention_weights, values)  # (3x3) * (3x4) = (3x4)

# 결과 출력
print("어텐션 가중치:\n", attention_weights)
print("가중합 벡터 (최종 출력):\n", weighted_sum)

입력 벡터: 3개의 단어를 4차원 임베딩으로 표현합니다.
Query, Key, Value 계산: 각 단어의 임베딩을 쿼리, 키, 값으로 변환합니다.
어텐션 스코어 계산: 각 단어 쌍 간의 유사도를 구하기 위해 쿼리와 키의 점곱(dot product)을 사용합니다.
Softmax 정규화: 어텐션 스코어를 확률 분포로 변환합니다.
가중합 계산: 어텐션 가중치와 값(Value)을 곱해 최종 가중합 벡터를 구합니다.

결론

이 코드는 Self-Attention의 기본적인 작동 원리를 보여줍니다. 각 입력 벡터(단어)가 다른 입력들과 얼마나 관련이 있는지를 계산해, 그에 따라 가중합 벡터를 생성합니다. 이런 메커니즘을 Transformer 모델 등에서 사용하여 문장 내에서 중요한 정보에 집중하게 합니다.

실무에선 구글 번역에서 Transformer 기반 모델을 사용합니다. 예를 들어 i'm going to the shop이라는 문장을 나는 가게에 간다로 번역할 때, 각 단어가 번역될 때마다 대응되는 단어에 집중합니다.

실제 동작:

"I"는 "나는"에, "shop"는 "가게"에 어텐션을 집중하여 번역합니다. 이 덕분에 문장 전체 문맥을 이해하고 자연스러운 번역이 가능합니다. (아~~ 내가 밥먹고 뭐시기뭐시기 친구만나서 카페갔다가~ 있지~ 지금 가게에 왔거든~ 근데 여기 가게는 뭐가유명해~? 라고 질문을 하면 GPT는 문맥을 파악하고 가게를 서치하여 필요한 정보를 제공합니다)

2024-10-17 실습 주가 예상 프로그램을 만들어 보자!

rwg5565 — Thu, 17 Oct 2024 15:00:34 +0900

Content

1. 데이터 수집

2. 데이터 전처리 : 결측치 처리 및 데이터 정규화

3. 모델 생성: LSTM 모델을 활용한 학습.

4. 모델 학습 및 평가: 학습된 모델로 테스트 데이터 예측

5. 결과 시각화: 실제 주가와 예측 주가 비교!

import yfinance as yf
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout

# 1. 데이터 수집: 삼성전자 주가 다운로드 (2013년 ~ 2024년)
data = yf.download("005930.KQ", start="2013-01-01", end="2024-12-31")

# 2. 데이터 전처리: 종가 데이터만 사용하고 정규화 수행
close_data = data[['Close']]
scaler = MinMaxScaler(feature_range=(0, 1))  # 0과 1 사이로 정규화
scaled_data = scaler.fit_transform(close_data)

# 3. 시계열 데이터 생성 함수
def create_dataset(data, time_step=60):
    X, Y = [], []
    for i in range(len(data) - time_step - 1):
        X.append(data[i:i + time_step, 0])
        Y.append(data[i + time_step, 0])
    return np.array(X), np.array(Y)

time_step = 60  # 60일치 데이터를 기반으로 예측
X, Y = create_dataset(scaled_data)

# 데이터 차원 조정
X = X.reshape(X.shape[0], X.shape[1], 1)

# 4. 훈련/테스트 데이터 분리
train_size = int(len(X) * 0.8)
X_train, X_test = X[:train_size], X[train_size:]
Y_train, Y_test = Y[:train_size], Y[train_size:]

# 5. LSTM 모델 구성
model = Sequential()
model.add(LSTM(50, return_sequences=True, input_shape=(time_step, 1)))
model.add(Dropout(0.2))
model.add(LSTM(50, return_sequences=False))
model.add(Dropout(0.2))
model.add(Dense(1))  # 예측할 종가 값

model.compile(optimizer='adam', loss='mean_squared_error')

# 6. 모델 학습 (학습 시간 단축을 위해 Epoch을 10으로 설정)
model.fit(X_train, Y_train, epochs=10, batch_size=32, validation_data=(X_test, Y_test))

# 7. 마지막 60일 데이터로 2025년 1년간의 주가 예측 수행
last_60_days = scaled_data[-time_step:]
X_input = last_60_days.reshape(1, time_step, 1)  # (1, 60, 1) 형태로 변환

predicted_prices = []

for _ in range(365):  # 2025년 365일 예측
    next_price = model.predict(X_input, verbose=0)  # 다음 날 예측
    predicted_prices.append(next_price[0, 0])  # 예측된 값 저장

    # 새로운 예측 값을 (1, 1, 1) 형태로 변환
    next_price_reshaped = next_price.reshape(1, 1, 1)

    # 입력 데이터 업데이트 (마지막 59개 값 + 새로운 예측 값)
    X_input = np.append(X_input[:, 1:, :], next_price_reshaped, axis=1)

# 8. 정규화 해제 (원래 가격 범위로 변환)
predicted_prices = scaler.inverse_transform(np.array(predicted_prices).reshape(-1, 1))

# 9. 미래 날짜 생성 (2025년 1월 1일부터 12월 31일까지)
future_dates = pd.date_range(start="2025-01-01", periods=365)

# 10. 예측 결과를 DataFrame으로 정리
predicted_df = pd.DataFrame(predicted_prices, columns=['Predicted Price'], index=future_dates)

# 11. y축을 한화(KRW)로 포맷하는 함수
def krw_format(x, _):
    return f"₩{int(round(x, -1)):,}"

# 12. 그래프 시각화
plt.figure(figsize=(12, 6))
plt.plot(predicted_df.index, predicted_df['Predicted Price'], label='Predicted Stock Price (2025)', color='blue')
plt.xlabel('Date')
plt.ylabel('Stock Price (KRW)')
plt.title('Samsung Stock Price Prediction (2025)')
plt.legend()

# y축에 한화(KRW) 형식으로 표시
ax = plt.gca()
ax.yaxis.set_major_formatter(plt.FuncFormatter(krw_format))

# 그래프 표시
plt.show()

예측 근거와 메커니즘

1. LSTM 모델의 역할

LSTM은 시계열 데이터(주가처럼 시간에 따라 변화하는 데이터)에서 과거 패턴을 학습하는 데 유리한 모델이야.
이 모델은 과거 일정 기간(여기선 60일)의 주가 데이터를 학습하고, 이전 데이터의 변화 추이를 바탕으로 다음 주가를 예측해.

LSTM 예측 과정 요약:

60일 간의 과거 데이터를 입력으로 사용.
과거 주가의 패턴을 학습하여 추세를 파악.
각 날의 예측을 다음 날 입력으로 사용하여 미래의 주가를 점진적으로 예측.

2. 학습 데이터의 근거

이 모델은 2013년부터 2024년까지의 삼성전자 주가 데이터를 사용.
학습 과정에서 모델은 주가의 상승/하락 패턴, 변동성 등을 이해하려고 시도.
LSTM은 특히 주가의 장기적인 추세와 단기적인 변동성을 모두 포착하려고 .

3. 모델의 한계

외부 요인 반영의 어려움:
- 이 모델은 과거 주가 데이터만을 사용하므로 금리, 환율, 정치적 사건 같은 외부 요인은 반영되지 않아.
- 실제 주가는 여러 외부 요인에 크게 영향을 받기 때문에 예측이 한계가 있을 수 있어.
데이터 패턴 의존성:
- 과거와 다른 패턴이 나타나면 예측의 정확도가 크게 떨어질 수 있다.
- 예를 들어, 갑작스러운 경제 위기나 기술 혁신 같은 이벤트는 모델이 미리 예측하기 어렵다.
장기 예측의 불확실성:
- 주가의 단기 예측은 어느 정도 정확할 수 있지만, 1년 이상 장기 예측에서는 불확실성이 크다

자 그러면 하나 하나 코드를 뜯어보며 공부를 해보자!

라이브러리 정리

yfinance: 주식 데이터를 불러오기 위해 사용.
numpy: 배열 연산을 쉽게 해주는 라이브러리.
pandas: 데이터를 다루기 쉽게 해주는 라이브러리.
matplotlib: 시각화를 위한 라이브러리.
MinMaxScaler: 데이터 정규화를 위해 사용.
Sequential, LSTM, Dense, Dropout: 딥러닝 모델(LSTM)을 만들기 위해 필요한 모듈

2. 데이터 수집: 삼성전자 주가 데이터 다운로드

python

data = yf.download("005930.KQ", start="2013-01-01", end="2024-12-31")

yf.download: 삼성전자(종목 코드: 005930.KQ)의 2013년부터 2024년까지의 주가 데이터를 불러옴.
start, end로 기간을 지정.

3. 종가 데이터만 사용하고 정규화 수행

python

close_data = data[['Close']] scaler = MinMaxScaler(feature_range=(0, 1)) # 0과 1 사이로 정규화 scaled_data = scaler.fit_transform(close_data)

close_data: 주식의 종가만 사용.
MinMaxScaler: 주가 데이터를 0~1 사이로 스케일링하여 LSTM 모델이 학습하기 쉽게 만듦.
정규화는 모델 학습을 더 잘하게 하는 데 도움을 줌.

4. 시계열 데이터 생성 함수 정의

python

def create_dataset(data, time_step=60): X, Y = [], [] for i in range(len(data) - time_step - 1): X.append(data[i:i + time_step, 0]) Y.append(data[i + time_step, 0]) return np.array(X), np.array(Y)

create_dataset: 주가 데이터를 슬라이딩 윈도우 방식으로 60일 단위로 묶음.
- X: 60일 간의 데이터를 입력으로 사용.
- Y: 다음 날의 종가를 예측할 목표 값으로 사용.

5. 시계열 데이터 생성

python

time_step = 60 # 60일치 데이터를 기반으로 예측 X, Y = create_dataset(scaled_data)

time_step = 60: 60일 동안의 데이터를 사용해 다음 날을 예측하도록 설정.

6. 데이터 차원 조정

python

X = X.reshape(X.shape[0], X.shape[1], 1)

LSTM은 (samples, time_steps, features) 형식의 데이터를 요구하기 때문에 데이터 차원을 조정.

7. 훈련/테스트 데이터 분리

python

train_size = int(len(X) * 0.8) X_train, X_test = X[:train_size], X[train_size:] Y_train, Y_test = Y[:train_size], Y[train_size:]

데이터를 80%는 훈련용, 20%는 테스트용으로 나눔.

8. LSTM 모델 구성

python

model = Sequential() model.add(LSTM(50, return_sequences=True, input_shape=(time_step, 1))) model.add(Dropout(0.2)) model.add(LSTM(50, return_sequences=False)) model.add(Dropout(0.2)) model.add(Dense(1)) # 예측할 종가 값

LSTM 레이어 2개를 사용.
- 첫 번째 LSTM 레이어는 return_sequences=True로 다음 레이어에 전체 시퀀스를 전달.
- 두 번째 LSTM 레이어는 마지막 값만 전달.
Dropout(0.2): 과적합 방지를 위해 일부 노드를 무작위로 비활성화.
Dense(1): 하나의 종가 값 예측.

9. 모델 컴파일

python

model.compile(optimizer='adam', loss='mean_squared_error')

Adam 최적화 알고리즘 사용.
손실 함수로 **Mean Squared Error(MSE)**를 사용해 예측과 실제 값의 차이를 최소화.

10. 모델 학습

python

model.fit(X_train, Y_train, epochs=10, batch_size=32, validation_data=(X_test, Y_test))

10번(Epochs) 동안 모델 학습.
batch_size=32: 매번 32개의 샘플씩 학습.
validation_data를 사용해 테스트 데이터를 평가.

11. 마지막 60일 데이터로 2025년 주가 예측

python

last_60_days = scaled_data[-time_step:] X_input = last_60_days.reshape(1, time_step, 1)

마지막 60일 데이터를 기반으로 2025년 주가를 예측하기 위한 입력 데이터 생성.

12. 2025년 1년간(365일) 주가 예측

python

predicted_prices = [] for _ in range(365): # 365일 예측 next_price = model.predict(X_input, verbose=0) # 다음 날 예측 predicted_prices.append(next_price[0, 0]) # 예측된 값 저장 # 새로운 예측 값을 (1, 1, 1) 형태로 변환 next_price_reshaped = next_price.reshape(1, 1, 1) # 입력 데이터 업데이트 (마지막 59개 값 + 새로운 예측 값) X_input = np.append(X_input[:, 1:, :], next_price_reshaped, axis=1)

매일 하나씩 2025년 1월 1일부터 12월 31일까지 예측.

13. 정규화 해제

python

predicted_prices = scaler.inverse_transform(np.array(predicted_prices).reshape(-1, 1))

정규화된 값을 원래 주가 범위로 변환.

14. 예측 결과를 DataFrame으로 정리

python

future_dates = pd.date_range(start="2025-01-01", periods=365) predicted_df = pd.DataFrame(predicted_prices, columns=['Predicted Price'], index=future_dates)

**미래 날짜(2025년)**와 예측된 주가를 DataFrame으로 정리.

15. y축을 한화(KRW)로 포맷하는 함수 정의

python

def krw_format(x, _): return f"₩{int(round(x, -1)):,}"

₩ 기호와 천 단위 콤마를 추가해 한화 형식으로 포맷.

16. 그래프 시각화

python

plt.figure(figsize=(12, 6)) plt.plot(predicted_df.index, predicted_df['Predicted Price'], label='Predicted Stock Price (2025)', color='blue') plt.xlabel('Date') plt.ylabel('Stock Price (KRW)') plt.title('Samsung Stock Price Prediction (2025)') plt.legend() ax = plt.gca() ax.yaxis.set_major_formatter(plt.FuncFormatter(krw_format)) plt.show()

예측된 주가를 시각화하고, y축에 한화(KRW) 형식을 적용.

결과

이 코드는 LSTM 모델을 사용해 2025년 1년간의 주가를 예측하고 시각화합니다.
주가를 예측할 때 마지막 60일 데이터를 사용하여 매일 하나씩 예측합니다.

오늘 공부하면서 느낀점:

LSTM(long-short term memory)모델은 시계열 데이터를 다룰 때 자주 사용된다. 주가 예측 처럼 시간에 따라 변화하는 데이터를 분석하기에 적합하다. 하지만 LSTM에는 장단이 존재하는데

LSTM의 장점과 단점 요약

장점 단점

장기 의존성 학습 가능	높은 계산 비용
기울기 소실 문제 해결	훈련 시간이 길다
시계열 및 순차 데이터에 적합	과적합 가능성
다양한 응용 분야에 사용 가능	모델 설계와 튜닝이 어려움
	장기 예측에서 정확도가 떨어질 수 있음

결론

LSTM은 시계열 데이터나 순차 데이터 처리에 매우 강력한 도구이지만, 복잡성과 긴 훈련 시간이 단점으로 작용합니다. 특히 주가 예측과 같이 외부 요인이 많이 작용하는 데이터에서는 한계가 있을 수 있습니다. 그래서 **외부 변수(금리, 유가 등)**를 함께 사용하는 다중변수 모델을 시도해보는 것도 좋은 방법!!

2024-10-15 programmers 입문 문제 풀이

rwg5565 — Tue, 15 Oct 2024 20:17:20 +0900

오늘 푼 문제

아이스아메리카노/중복된 개수 세기/머쓱이 보다 큰 사람/ 중앙 값 구하기/등등 입문문제

마크다운

마크다운: 태그를 이용해서 문서를 나타내는 표현법 .md (Readme.md) 설명하는 문제
git: 분산 버전 관리 시스템
버전 관리: 코드의 히스토리를 관리하는 도구 개발되어온 과정을 파악할 수 있음
이전 버전과의 변경 사항 비교 및 분석 가능

git
ls 현재 위치에서
clear 초기화
~ 홈 위치를 의미
pwd 현재 위치 보기(git의 위치)

working Directory:
내 폴더(작업 공간) .git이 들어있는 위치 가장 최상단의 위치

straging area:
commit으로 남기고 싶은, 특정 버전으로 관리하고 싶은 파일들이 있는 곳(미래)

repository:
commit들이 저장되는 곳

working directory: 작업전 staging area: 남기고 싶은 관리하고 싶은 백 스테이지 (중간 수정 하고 있는 것) repository: staging area 저장된 것들

2024-10-14

rwg5565 — Mon, 14 Oct 2024 20:00:39 +0900

1.import 만들기

import란? 이미 만들어져 있고 검증된 함수들을 성격에 맞게 하나의 파이썬 파일에 묶어 만들어 놓은 것을 모듈이라고 하는데 모듈을 불러 오는 것을 임포트(import)라 한다.

ex)) study.py 라는 파일을 하나 만들고 거기에 내가 원하는 공식을 넣는다.

def add_txt(t1,t2):

return t1 + ':' + t2

def reverse(x,y,z):

return z,y,x

그리고

사용하려는 곳에 import study 해주고~

import study

ret1 = mylib.add_txt('대한민국','1등')

ret2 = mylib.reverse(1,2,3)

print(ret1)

print(ret2)

이렇게 하면~ 출력 값이

대한민국:1등
(3, 2, 1) 이런 식으로 나오게 된다.

존재하지 않은 모듈을 임포트 하면 다음과 같은 오류가 발생한다.

ImportError : no module named '~~~"

2024-10-14 Algorithm 개념 study

rwg5565 — Mon, 14 Oct 2024 15:29:31 +0900

content

1.dip-running

2.ann (인공 신경망)

1. 딥러닝이란???

인공신경망

데이터에서 패턴(중요한정보)를 추출하여 예측,분류,생성 등 다양한 작업을 수행 한다.

!예시!

예측: stock의 흐름이라던가\n부동산의 시세라던가\n

분류: 명확한 사물 데이터가 있는 개나 고양이 같이 분류가 되는 것\n

생성: 창조의 영역 !chat gpt!

perceptron: 사람의 뇌(뉴런) 입력 값이 여러 개 들어오면 perceptron이 계산한다.

EX))

개 다리 4개 개의 귀2개 / 사람 다리 2개 사람 귀 2개 = 4*2=6 2*2=4

개는 항상 6의 값이 나오고 사람은 항상 값이 4가 나오니 4는 사람이고 6은 개다.

다층 perceptron: 이런 perceptron을 많이 설정하면 설정 할 수록 정확한 값이 나온다.

2024-10-11 파이썬으로 운동일지 만들어보기!(1)

rwg5565 — Fri, 11 Oct 2024 18:34:38 +0900

!나만의 운동일지 만들어보기!

운동 데이터베이스 구축
운동 루틴 추천
컴퓨터 비전을 통한 실시간 자세 분석
자연어 처리 기능

우선 운동일지를 작성 할 수 있는 코드를 python으로 만들었습니다

import csv

from datetime import datetime

# 사용자가 운동을 기록할 수 있는 함수

def record_exercise():

# 사용자로부터 운동 정보 입력받기

exercise_name = input("운동 이름을 입력하세요: ")

muscle_group = input("운동 부위를 입력하세요: ")

difficulty = input("운동 난이도를 입력하세요 (예: 초급, 중급, 고급): ")

sets = int(input("세트 수를 입력하세요: "))

reps = int(input("반복 횟수를 입력하세요: "))

weight = input("중량을 입력하세요: ")

# 오늘 날짜 기록

today = datetime.now().strftime('%Y-%m-%d')

# CSV 파일에 운동 기록 저장

with open('user_exercise_records.csv', mode='a', newline='') as file:

writer = csv.DictWriter(file, fieldnames=["date", "name", "muscle_group", "difficulty", "sets", "reps", "weight", "description"])

if file.tell() == 0: # 파일이 비어있으면 헤더 작성

writer.writeheader()

writer.writerow({

"date": today,

"name": exercise_name,

"muscle_group": muscle_group,

"difficulty": difficulty,

"sets": sets,

"reps": reps,

"weight": weight,

"description": "" # 설명 필드가 필요할 경우 추가

})

print(f"{exercise_name} 운동 기록이 저장되었습니다.")

# 기록된 운동 데이터를 조회하는 함수

def view_exercise_records():

try:

with open('user_exercise_records.csv', mode='r') as file:

reader = csv.DictReader(file)

print("기록된 운동 데이터:")

print(f"{'날짜':<12} {'운동 이름':<15} {'운동 부위':<10} {'난이도':<6} {'세트':<4} {'반복 횟수':<5} {'중량':<6}")

print("-" * 80)

# CSV 파일을 읽어 운동 기록 출력

for row in reader:

print(f"{row['date']:<12} {row['name']:<15} {row['muscle_group']:<10} {row['difficulty']:<6} {row['sets']:<4} {row['reps']:<5} {row['weight']:<6}")

except FileNotFoundError:

print("운동 기록 파일을 찾을 수 없습니다. 먼저 운동 기록을 저장해 주세요.")

# 기록된 운동 데이터 조회

view_exercise_records()

# 사용자로부터 운동 기록을 입력받아 저장하는 함수 호출

record_exercise()

결과:

중량을 입력하세요: 60
벤치 운동 기록이 저장되었습니다.
(.venv)
KJI@DESKTOP-I09HHBD MINGW64 C:/Users/KJI/AppData/Local/Programs/Microsoft VS Code
$ python wl.py
기록된 운동 데이터:
날짜 운동 이름 운동 부위 난이도 세트 반복 횟수 중량
--------------------------------------------------------------------------------
2024-10-11 벤치 가슴 초급 3 10 60

이런 느낌으로 완성 되었는데요

이것을 앱으로 사용 할 수 있게 바꿔보고 싶었습니다. 하지만 window 에서 ios 앱 개발은 불가능 하다고 하네요 .. 나중에 돈 모아서 맥북도 하나 사야겠습니다 ㅋㅋㅋ 해보고 싶은게 너무 많아요,,

from kivy.app import App

from kivy.uix.boxlayout import BoxLayout

from kivy.uix.label import Label

from kivy.uix.textinput import TextInput

from kivy.uix.button import Button

from kivy.uix.popup import Popup

from kivy.core.window import Window

from kivy.core.text import LabelBase

import csv

from datetime import datetime

# 사용자 정의 폰트 등록 (폰트 파일 경로 수정)

LabelBase.register(name="NotoSans", fn_regular="NotoSansKR-VariableFont_wght.ttf")

class WorkoutApp(App):

def build(self):

# 창 배경색을 흰색으로 설정

Window.clearcolor = (1, 1, 1, 1) # 흰색 배경

# 메인 레이아웃

self.layout = BoxLayout(orientation='vertical', padding=10, spacing=10)

# 입력 필드 생성

self.exercise_input = self.create_text_input("운동 이름:")

self.muscle_group_input = self.create_text_input("운동 부위:")

self.difficulty_input = self.create_text_input("난이도 (초급/중급/고급):")

self.sets_input = self.create_text_input("세트 수:")

self.reps_input = self.create_text_input("반복 횟수:")

self.weight_input = self.create_text_input("중량 (예: 20kg):")

# 운동 기록 저장 버튼

save_button = Button(text="운동 기록 저장", size_hint_y=None, height=50, background_color=(0.3, 0.6, 1, 1), color=(1, 1, 1, 1), font_name="NotoSans")

save_button.bind(on_press=self.record_exercise)

self.layout.add_widget(save_button)

# 기록된 운동 조회 버튼

view_button = Button(text="기록된 운동 조회", size_hint_y=None, height=50, background_color=(0.2, 0.8, 0.2, 1), color=(1, 1, 1, 1), font_name="NotoSans")

view_button.bind(on_press=self.view_exercise_records)

self.layout.add_widget(view_button)

return self.layout

# 텍스트 입력 필드 생성 함수

def create_text_input(self, label_text):

box = BoxLayout(orientation='horizontal', size_hint_y=None, height=40)

label = Label(text=label_text, size_hint_x=0.4, font_name="NotoSans", color=(0, 0, 0, 1)) # 텍스트 색 검정

text_input = TextInput(multiline=False, size_hint_x=0.6, background_color=(0.9, 0.9, 0.9, 1), foreground_color=(0, 0, 0, 1)) # 입력 필드 색상 조정

box.add_widget(label)

box.add_widget(text_input)

self.layout.add_widget(box)

return text_input

# 운동 기록 저장 함수

def record_exercise(self, instance):

exercise_name = self.exercise_input.text

muscle_group = self.muscle_group_input.text

difficulty = self.difficulty_input.text

sets = self.sets_input.text

reps = self.reps_input.text

weight = self.weight_input.text

today = datetime.now().strftime('%Y-%m-%d')

# CSV 파일에 운동 기록 저장

with open('user_exercise_records.csv', mode='a', newline='') as file:

writer = csv.DictWriter(file, fieldnames=["date", "name", "muscle_group", "difficulty", "sets", "reps", "weight", "description"])

if file.tell() == 0:

writer.writeheader()

writer.writerow({

"date": today,

"name": exercise_name,

"muscle_group": muscle_group,

"difficulty": difficulty,

"sets": sets,

"reps": reps,

"weight": weight,

"description": ""

})

self.show_popup("운동 기록", f"{exercise_name} 운동 기록이 저장되었습니다.")

# 운동 기록 조회 함수

def view_exercise_records(self, instance):

try:

with open('user_exercise_records.csv', mode='r') as file:

reader = csv.DictReader(file)

records = "기록된 운동 데이터:\n"

records += f"{'날짜':<12} {'운동 이름':<15} {'운동 부위':<10} {'난이도':<6} {'세트':<4} {'반복 횟수':<5} {'중량':<6}\n"

records += "-" * 80 + "\n"

for row in reader:

records += f"{row['date']:<12} {row['name']:<15} {row['muscle_group']:<10} {row['difficulty']:<6} {row['sets']:<4} {row['reps']:<5} {row['weight']:<6}\n"

self.show_popup("운동 기록 조회", records)

except FileNotFoundError:

self.show_popup("오류", "운동 기록 파일을 찾을 수 없습니다. 먼저 운동 기록을 저장해 주세요.")

# 팝업 메시지 표시 함수

def show_popup(self, title, message):

popup_layout = BoxLayout(orientation='vertical', padding=10)

message_label = Label(text=message, font_name="NotoSans", color=(0, 0, 0, 1)) # 텍스트 검정

close_button = Button(text="닫기", size_hint_y=None, height=50, font_name="NotoSans") # 팝업 버튼 폰트 적용

popup_layout.add_widget(message_label)

popup_layout.add_widget(close_button)

popup = Popup(title=title, content=popup_layout, size_hint=(0.8, 0.8))

close_button.bind(on_press=popup.dismiss)

popup.open()

# 앱 실행

if __name__ == '__main__':

WorkoutApp().run()

실행 결과

이런식으로 깔끔하게 뜨네요 폰트는 NotoSansKR-VariableFont 사용했습니다

2024-10-10 코딩테스트 입문 공부

rwg5565 — Thu, 10 Oct 2024 20:56:17 +0900

문자열 출력하기

문자열 str이 주어질 때, str을 출력하는 코드를 작성해 보세요.

#include <stdio.h>
#define LEN_INPUT 1000001

int main(void) {
    char s1[LEN_INPUT];
    scanf("%s", s1);

    return 0;
}

출력하는 printf("%s",s1); 을 추가해 주면 된다!

정수 a와 b가 주어집니다. 각 수를 입력받아 입출력 예와 같은 형식으로 출력하는 코드를 작성해 보세요.

#include <stdio.h>

int main(void) {
    int a;
    int b;
    scanf("%d %d", &a, &b);
    printf("%d", a + b);
    return 0;
}

문제는 a와 b의 정수를 출력하는 거니 printf("a = %b\n", a), printf("b = %b\n", b) 출력 해주는 함수를 적어준다!

문자열 str과 정수 n이 주어집니다.
str이 n번 반복된 문자열을 만들어 출력하는 코드를 작성해 보세요.

int main(void) {
    char s1[LEN_INPUT];
    int a;
    scanf("%s %d", s1, &a);
    return 0;
}

여기서 str이 n번(입력값) 만큼 반복되게 하는 함수 그리고 프린트 해주는 구문만 추가해주면 된다

for( int i = 0; i < a; i++) {

printf( "%s" , s1); (여기서 s1은 저장된 문자열 그리고 a는 입력되는 값)

2024-10-10 list dictionary tuple function

rwg5565 — Thu, 10 Oct 2024 15:00:59 +0900

List : 여러 개의 값을 저장할 수 있는 자료형

my_list = [1,2,3,4]

Dictionary: 키 값 쌍으로 이루어진 자료 구조

my_dict = {'name', 'leo', 'age':25}

Tuple: 리스트와 유사 한 번 선언 되면 값을 변경할 수 없다.

my_tuple = (1,2,3)

알고리즘이란 문제를 해결하기 위한 단계적 절차로, 데이터 구조를 효율적으로 사용하는 방법

list 값에서 최대 값 찾기

def find_max(my_list):
    max_value = my_list[0]
    for num in my_list:
        if num > max_value:
            max_value = num
    return max_value

2024-10-09 Python 라이브러리로 데이터 분석하기

rwg5565 — Wed, 9 Oct 2024 19:34:38 +0900

import pandas as pd

# 기존 DataFrame 불러오기
file_path = 'your_excel_file_path.xlsx'
df = pd.read_excel(file_path)

# 경찰서명과 구 이름을 매핑한 사전 (예시)
mapping_dict = {
    '중부서': '중구',
    '종로서': '종로구',
    '남대문서': '중구',
    '서대문서': '서대문구',
    # 나머지 경찰서명과 구 이름을 여기에 추가
}

# '구별' 컬럼 생성, 매칭되지 않는 값에는 '구 없음'을 할당
df['구별'] = df['관서명'].map(mapping_dict).fillna('구 없음')

# 각 범죄별 검거율 계산
df['강간검거율'] = (df['강간(검거)'] / df['강간(발생)']) * 100
df['강도검거율'] = (df['강도(검거)'] / df['강도(발생)']) * 100
df['살인검거율'] = (df['살인(검거)'] / df['살인(발생)']) * 100
df['절도검거율'] = (df['절도(검거)'] / df['절도(발생)']) * 100
df['폭력검거율'] = (df['폭력(검거)'] / df['폭력(발생)']) * 100

# 전체 검거율 계산 (총 검거 / 총 발생)
df['검거율'] = (df['소계(검거)'] / df['소계(발생)']) * 100

# 필요 없는 컬럼 삭제
del df['강간(검거)']
del df['강도(검거)']
del df['살인(검거)']
del df['절도(검거)']
del df['폭력(검거)']
del df['소계(발생)']
del df['소계(검거)']

# 컬럼명 변경
df = df.rename(columns={
    '강간(발생)': '강간',
    '강도(발생)': '강도',
    '살인(발생)': '살인',
    '절도(발생)': '절도',
    '폭력(발생)': '폭력'
})

# 구별로 데이터를 집계 (관서명을 구별로 바꿔서 합계 구하기)
pivot_df = pd.pivot_table(df,
                          index='구별',  # 구별로 그룹화
                          aggfunc='sum')  # 합계를 구함

# '구 없음' 행을 삭제
pivot_df = pivot_df.drop('구 없음', errors='ignore')

# 결과 출력
print(pivot_df.head())

2024-10-08 (class OOP 공부)

rwg5565 — Tue, 8 Oct 2024 16:32:36 +0900

class란 해당 정보를 담고 이후 그 정보를 출력하는 간단한 구조

class example))

class person:

pass<- (잠깐 대기라는 뜻)

alice = Person()

class Person:

def __init__(self, name, gender, age):

self.name = name

self.gender = gender

self.age = age

여기서 그냥 name 와 self.name 다른점

만약 name을 self 없이 사용하면, self.name이라는 속성을 정의하지 않기 때문에, 인스턴스에서 그 속성을 사용할 수 없게 돼. 즉, name이라는 변수는 display() 메소드 안에서만 존재하고, 인스턴스 외부에서는 접근할 수 없다.

self.name: 클래스 인스턴스의 속성을 정의하여, 해당 객체가 가지고 있는 데이터로 저장.
name: 생성자 메소드에서 전달받은 매개변수로, 객체 외부에서는 접근할 수 없음

self를 사용하면 각 객체는 자신의 고유한 속성을 가질 수 있다!!

def display(self):

print(f"이름: {self.name}, 성별: {self.gender}")

print(f"나이: {self.age}

if self.age >= 18:

print(f:"안녕하세요, {self.name}! 성인이시군요!")

else:

print (f:"안녕하세요, {self.name}! 학생이시군요!")

name_input = input("이름을 입력하세요: ")

age_input = (int(input("이름을 입력하세요: "))

while True:

gender_input = input("성별을 입력하세요 (남/여):"lower()

if gender_input in ['male', 'femal']:

break

else:

print("잘못 입력 했다. "남" 또는 "여"라고 입력해주세요!!!.")

person = Person(name_input, gender_input, age_input)

person.display() 출력

요약하자면 성별 나이 이름을 입력하는 class를 만들어 보았다 그리고 성별을 다르게 입력하면 제대로 입력하라고 하는 경고문도 만들어 보았다.

다시 한번 모아서 정리하자

class Person:
    # 생성자 정의: name, gender, age를 초기화
    def __init__(self, name, gender, age):
        self.name = name
        self.gender = gender
        self.age = age

    # display 함수: 이름과 성별은 같은 줄에, 나이는 다음 줄에 출력
    def display(self):
        print(f"이름: {self.name}, 성별: {self.gender}")
        print(f"나이: {self.age}")
        if self.age >= 18:
            print(f"안녕하세요, {self.name}! 성인이시군요!")
        else:
            print(f"안녕하세요, {self.name}! 아직 미성년자이시군요!")

# 사용자 입력 받기
name_input = input("이름을 입력하세요: ")
age_input = int(input("나이를 입력하세요: "))

# 성별 입력 제한: male 또는 female만 허용
while True:
    gender_input = input("성별을 입력하세요 (male/female): ").lower()
    if gender_input in ['male', 'female']:
        break
    else:
        print("잘못된 성별을 입력하셨습니다. 'male' 또는 'female'을 입력하세요.")

# 입력 받은 값으로 Person 객체 생성
person = Person(name_input, gender_input, age_input)

# 객체의 정보를 출력
person.display()