데이터를 AI로
어떻게 분석할 것인가

import pandas as pd

# 1) CSV 불러오기 (한글 깨짐 시 encoding='cp949' 또는 'utf-8-sig' 시도)
df = pd.read_csv('data.csv')

# 2) 기본 구조 확인
print('행, 열 개수:', df.shape)
print(df.head(10))
print(df.info())

# 3) 결측치 확인
missing = df.isna().sum().sort_values(ascending=False)
missing_rate = (df.isna().mean() * 100).round(2)
print(pd.DataFrame({'결측개수': missing, '결측률(%)': missing_rate}))

# 4) 수치형 변수 요약
print(df.describe())

# 5) 범주형 변수 고유값 확인 (오타 발견용)
for col in df.select_dtypes(include='object').columns:
    print(f'\n[{col}] 고유값 {df[col].nunique()}개')
    print(df[col].value_counts().head(10))

# 6) 중복 행 확인
print('중복 행 수:', df.duplicated().sum())

import pandas as pd
import matplotlib.pyplot as plt

# 예: condition 열에는 조건명, value 열에는 측정값이 있다고 가정
df = pd.read_csv('experiment.csv')

summary = df.groupby('condition')['value'].agg(['count', 'mean', 'std']).reset_index()
summary['se'] = summary['std'] / (summary['count'] ** 0.5)  # 표준오차
print(summary)

# 표준편차(SD) 오차막대: 자료 자체의 흩어짐
# 표준오차(SE) 오차막대: 평균 추정의 불확실성
# 그래프 캡션에 어떤 오차인지 반드시 명시할 것
plt.figure(figsize=(8, 5))
plt.bar(summary['condition'], summary['mean'], yerr=summary['std'],
        capsize=5, color='#2563eb', alpha=0.7, edgecolor='#0f2454')
plt.xlabel('Condition')
plt.ylabel('Mean value (단위 명시)')
plt.title(f'Mean ± SD by condition (n={summary["count"].iloc[0]})')
plt.tight_layout()
plt.show()

import pandas as pd

df = pd.read_csv('data.csv')
col = 'value'

# IQR 방식 (분포 가정 없음, 일반적으로 권장)
q1 = df[col].quantile(0.25)
q3 = df[col].quantile(0.75)
iqr = q3 - q1
lower = q1 - 1.5 * iqr
upper = q3 + 1.5 * iqr

outliers = df[(df[col] < lower) | (df[col] > upper)]
print(f'IQR 기준 하한: {lower:.3f}, 상한: {upper:.3f}')
print(f'이상치 후보 수: {len(outliers)} / 전체 {len(df)}')
print(outliers)

# z-score 방식은 정규분포 가정에 가까울 때만 사용
# 치우친 분포에서는 IQR 또는 비율 기준이 더 안전
z_scores = ((df[col] - df[col].mean()) / df[col].std()).abs()
print(f'\nz-score > 3인 행 수: {(z_scores > 3).sum()}')

# 삭제하기 전 확인할 것:
# 1. 측정 당시 장비 오류가 있었는가?
# 2. 단위 입력 오류인가?
# 3. 실제로 의미 있는 특이 사례인가?
# 4. 삭제 전후 결론이 달라지는가? (sensitivity check)

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

# 수치형 열만 선택
df = pd.read_csv('data.csv')
num = df.select_dtypes(include='number')

corr = num.corr()
print(corr.round(3))

# Heatmap: 발산형 색(diverging) 사용 - 양수/음수 상관을 시각적으로 구분
plt.figure(figsize=(8, 6))
plt.imshow(corr, aspect='auto', cmap='RdBu_r', vmin=-1, vmax=1)
plt.colorbar(label='Correlation')
plt.xticks(range(len(corr.columns)), corr.columns, rotation=90)
plt.yticks(range(len(corr.columns)), corr.columns)
# 셀에 값 표시
for i in range(len(corr.columns)):
    for j in range(len(corr.columns)):
        plt.text(j, i, f'{corr.iloc[i,j]:.2f}', ha='center', va='center',
                 color='white' if abs(corr.iloc[i,j])>0.5 else 'black', fontsize=8)
plt.title('Correlation matrix')
plt.tight_layout()
plt.show()

# 두 변수 산점도 예시
plt.figure(figsize=(6, 5))
plt.scatter(df['x'], df['y'], alpha=0.6, edgecolor='white')
plt.xlabel('x (단위)')
plt.ylabel('y (단위)')
plt.title(f'Scatter plot (n={len(df)})')
plt.tight_layout()
plt.show()

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score, mean_absolute_error

df = pd.read_csv('data.csv').dropna(subset=['x', 'y'])
X = df[['x']]
y = df['y']

model = LinearRegression()
model.fit(X, y)
pred = model.predict(X)

print(f'회귀식: y = {model.coef_[0]:.4f} * x + {model.intercept_:.4f}')
print(f'R²: {r2_score(y, pred):.3f}')
print(f'MAE: {mean_absolute_error(y, pred):.3f}')

# 잔차 분석: 패턴이 있으면 선형 가정 위반 가능
residuals = y - pred
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.scatter(df['x'], y, label='data', alpha=0.6)
plt.plot(df['x'], pred, color='red', label='linear fit')
plt.xlabel('x'); plt.ylabel('y'); plt.legend()
plt.title(f'Linear regression (R²={r2_score(y, pred):.3f})')

plt.subplot(1, 2, 2)
plt.scatter(pred, residuals, alpha=0.6)
plt.axhline(0, color='red', linestyle='--')
plt.xlabel('Predicted'); plt.ylabel('Residual')
plt.title('Residual plot (패턴이 없어야 함)')
plt.tight_layout()
plt.show()

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score, mean_absolute_error

df = pd.read_csv('data.csv')
features = ['x1', 'x2', 'x3']
X = df[features]
y = df['target']

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)

# 훈련/검증 성능 비교: 격차가 크면 과적합
for name, X_part, y_part in [('train', X_train, y_train), ('test', X_test, y_test)]:
    pred = model.predict(X_part)
    print(f'{name}  R²={r2_score(y_part, pred):.3f}  MAE={mean_absolute_error(y_part, pred):.3f}')

# 계수 (영향 크기 순서)
coef = pd.Series(model.coef_, index=features).sort_values(key=abs, ascending=False)
print('\n[계수]\n', coef)

# 다중공선성 확인: VIF가 10 이상이면 변수 간 중복이 심함
# (statsmodels 설치: pip install statsmodels)
try:
    from statsmodels.stats.outliers_influence import variance_inflation_factor
    vif = pd.DataFrame({
        'feature': features,
        'VIF': [variance_inflation_factor(X.values, i) for i in range(len(features))]
    })
    print('\n[VIF] (10 이상이면 다중공선성 의심)\n', vif)
except ImportError:
    # statsmodels 없으면 상관행렬로 대체 점검
    print('\n[변수 간 상관 (|r|>0.8이면 중복 의심)]')
    print(X.corr().round(2))

import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import confusion_matrix, classification_report, ConfusionMatrixDisplay

df = pd.read_csv('classification.csv')
features = ['x1', 'x2', 'x3']
X = df[features]
y = df['label']

# stratify=y : 클래스 비율을 유지하며 분리 (불균형 데이터에 필수)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# class_weight='balanced' : 소수 클래스에 가중치
model = RandomForestClassifier(random_state=42, class_weight='balanced', n_estimators=100)
model.fit(X_train, y_train)
pred = model.predict(X_test)

print('=== 혼동행렬 ===')
print(confusion_matrix(y_test, pred))
print('\n=== 분류 리포트 ===')
print(classification_report(y_test, pred))

# 시각화
ConfusionMatrixDisplay.from_predictions(y_test, pred, cmap='Blues')
plt.title('Confusion Matrix')
plt.tight_layout()
plt.show()

# 변수 중요도 (예측 기여도 - 인과 효과 아님!)
importance = pd.Series(model.feature_importances_, index=features).sort_values()
plt.figure(figsize=(7, 4))
importance.plot(kind='barh', color='#06b6d4')
plt.xlabel('Importance (예측 기여도)')
plt.title('Feature importance')
plt.tight_layout()
plt.show()

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
from sklearn.decomposition import PCA

df = pd.read_csv('data.csv')
features = ['x1', 'x2', 'x3', 'x4']
X = df[features].dropna()

# 표준화: 단위가 다른 변수를 동등하게 비교
X_scaled = StandardScaler().fit_transform(X)

# Elbow method: 적절한 k 찾기
inertias = []
ks = range(2, 8)
for k in ks:
    km = KMeans(n_clusters=k, random_state=42, n_init=10)
    km.fit(X_scaled)
    inertias.append(km.inertia_)

plt.figure(figsize=(6, 4))
plt.plot(ks, inertias, 'o-', color='#2563eb')
plt.xlabel('Number of clusters (k)')
plt.ylabel('Inertia (within-cluster sum of squares)')
plt.title('Elbow method')
plt.tight_layout()
plt.show()

# 최종 모델 (예시: k=3, elbow 결과 보고 조정)
k = 3
kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
clusters = kmeans.fit_predict(X_scaled)
X['cluster'] = clusters

# PCA로 2차원 시각화 (군집별 색 구분 + 범례)
pca = PCA(n_components=2)
XY = pca.fit_transform(X_scaled)

plt.figure(figsize=(7, 5))
colors = ['#2563eb', '#10b981', '#f59e0b', '#7c3aed', '#ef4444', '#06b6d4']
for c in range(k):
    mask = clusters == c
    plt.scatter(XY[mask, 0], XY[mask, 1], c=colors[c], label=f'Cluster {c}',
                alpha=0.7, edgecolor='white', s=50)
plt.xlabel(f'PC1 ({pca.explained_variance_ratio_[0]*100:.1f}%)')
plt.ylabel(f'PC2 ({pca.explained_variance_ratio_[1]*100:.1f}%)')
plt.title(f'K-means clusters (k={k}) projected by PCA')
plt.legend()
plt.tight_layout()
plt.show()

# 군집별 프로파일: 각 군집의 평균값으로 이름 붙이기
print('=== 군집별 평균값 (원자료 단위) ===')
print(X.groupby('cluster')[features].mean().round(3))

import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv('sensor.csv')
df['time'] = pd.to_datetime(df['time'])
df = df.sort_values('time').reset_index(drop=True)

col = 'value'
window = 12  # 이동 창 크기 (데이터 간격에 맞게 조정)

# 이동평균과 이동표준편차 (rolling): 시계열 추세를 반영한 이상 탐지
df['moving_avg'] = df[col].rolling(window=window, min_periods=1, center=True).mean()
df['moving_std'] = df[col].rolling(window=window, min_periods=1, center=True).std()

# 이상 구간: 이동평균 ± 3 * 이동표준편차 범위를 벗어난 점
df['upper'] = df['moving_avg'] + 3 * df['moving_std']
df['lower'] = df['moving_avg'] - 3 * df['moving_std']
df['anomaly'] = (df[col] > df['upper']) | (df[col] < df['lower'])

print(f'전체 {len(df)}개 중 이상 후보: {df["anomaly"].sum()}개')

plt.figure(figsize=(12, 5))
plt.plot(df['time'], df[col], label='raw', color='#cbd5e1', linewidth=0.8)
plt.plot(df['time'], df['moving_avg'], label='moving average', color='#2563eb', linewidth=2)
plt.fill_between(df['time'], df['lower'], df['upper'], alpha=0.15, color='#2563eb', label='±3 SD band')
plt.scatter(df.loc[df['anomaly'], 'time'], df.loc[df['anomaly'], col],
            color='#ef4444', label='anomaly', zorder=5, s=40)
plt.xlabel('Time')
plt.ylabel(col)
plt.title(f'Rolling mean anomaly detection (window={window})')
plt.legend()
plt.tight_layout()
plt.show()

# 이상으로 표시된 점이 정말 이상인지 원자료와 측정 로그를 직접 확인할 것
# 센서 고장, 정상 변동, 진짜 이상사건을 구분하는 것은 사람의 몫

from collections import Counter
import pandas as pd
import matplotlib.pyplot as plt
import re

df = pd.read_csv('text.csv')
texts = df['text'].dropna().astype(str)

# ====== 방법 A: 라이브러리 없이 간단 처리 (영문/단순 한글) ======
# - 빠르지만 한국어 조사가 단어에 붙어 나옴 ("학교는", "학교를"이 다른 단어로 카운트됨)
stopwords = {'그리고','하지만','또한','대한','관련','으로','에서','이다','있다','이다','하는',
             '이런','그런','저런','우리','저희','때문','정도','이번','다음','경우'}

words = []
for text in texts:
    # 특수문자 제거
    cleaned = re.sub(r'[^\w\s가-힣]', ' ', text)
    for w in cleaned.split():
        w = w.strip()
        if len(w) >= 2 and w not in stopwords:
            words.append(w)

counter = Counter(words)
top = pd.DataFrame(counter.most_common(20), columns=['word', 'count'])
print(top)

plt.figure(figsize=(9, 5))
plt.barh(top['word'][::-1], top['count'][::-1], color='#2563eb')
plt.xlabel('Count')
plt.title('Top 20 keywords (간단 처리)')
plt.tight_layout()
plt.show()

# ====== 방법 B: KoNLPy로 명사만 추출 (정확하지만 설치 필요) ======
# pip install konlpy   (Mac/Linux는 Java 설치 필요)
# from konlpy.tag import Okt
# okt = Okt()
# nouns = []
# for text in texts:
#     for n in okt.nouns(text):
#         if len(n) >= 2 and n not in stopwords:
#             nouns.append(n)
# Counter(nouns).most_common(20)

# ====== 방법 C: 형태소 분석 없이도 정확도를 올리는 방법 ======
# - 조사 목록을 만들어 단어 끝에서 제거
# - 자주 등장하는 어미("입니다", "합니다") 제외
# - 길이 3자 이상만 유지

import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer

df = pd.read_csv('documents.csv')
texts = df['text'].fillna('').astype(str).tolist()

# 한국어는 token_pattern을 한글 포함으로 설정
vectorizer = TfidfVectorizer(
    max_features=1000,
    token_pattern=r'(?u)\b[\w가-힣]{2,}\b',
    min_df=2  # 최소 2개 문서에 등장한 단어만
)
X = vectorizer.fit_transform(texts)
terms = vectorizer.get_feature_names_out()

# 각 문서별 특징어 상위 10개
for doc_idx in range(min(5, len(texts))):  # 처음 5개 문서만 출력
    row = X[doc_idx].toarray().ravel()
    top_idx = row.argsort()[-10:][::-1]
    print(f'\n[문서 {doc_idx}] 특징어:')
    for i in top_idx:
        if row[i] > 0:
            print(f'  {terms[i]}: {row[i]:.3f}')

# pip install Pillow numpy pandas
from PIL import Image
import numpy as np
import pandas as pd
from pathlib import Path

records = []
image_folder = Path('images')

for file in sorted(image_folder.glob('*.jpg')):
    img = Image.open(file).convert('RGB')
    arr = np.array(img)
    mean_rgb = arr.reshape(-1, 3).mean(axis=0)
    brightness = arr.mean()  # 전체 픽셀 평균 밝기
    # HSV로 변환해 색조(Hue) 평균도 함께 추출
    hsv = np.array(img.convert('HSV'))
    hue_mean = hsv[..., 0].mean()
    records.append({
        'file': file.name,
        'R_mean': round(mean_rgb[0], 2),
        'G_mean': round(mean_rgb[1], 2),
        'B_mean': round(mean_rgb[2], 2),
        'brightness': round(brightness, 2),
        'hue_mean': round(hue_mean, 2)
    })

result = pd.DataFrame(records)
print(result)
result.to_csv('image_color_summary.csv', index=False, encoding='utf-8-sig')

# 주의: 촬영 조명·각도·거리·배경이 달라지면 색 변화가 왜곡됨
# - 같은 조명, 같은 거리, 같은 배경으로 촬영
# - 색 표준카드(컬러체커)나 흰색 기준판을 함께 촬영해 보정

import numpy as np
import matplotlib.pyplot as plt

# 재현성: 같은 seed로 결과 고정
rng = np.random.default_rng(seed=42)

# 예: 밀도 = 질량 / 부피
# 질량은 평균 10.0g, 표준편차 0.2g / 부피는 평균 5.0mL, 표준편차 0.1mL라고 가정
n = 10000
mass = rng.normal(loc=10.0, scale=0.2, size=n)
volume = rng.normal(loc=5.0, scale=0.1, size=n)
density = mass / volume

p025, p975 = np.percentile(density, [2.5, 97.5])
print(f'평균 밀도: {density.mean():.4f} g/mL')
print(f'표준편차: {density.std():.4f}')
print(f'95% 범위: [{p025:.4f}, {p975:.4f}]')
print(f'특정 기준(2.05 g/mL) 초과 확률: {(density > 2.05).mean()*100:.2f}%')

plt.figure(figsize=(8, 5))
plt.hist(density, bins=50, color='#2563eb', alpha=0.7, edgecolor='white')
plt.axvline(density.mean(), color='red', linestyle='--', label=f'mean={density.mean():.3f}')
plt.axvline(p025, color='orange', linestyle=':', label=f'95% CI')
plt.axvline(p975, color='orange', linestyle=':')
plt.xlabel('Density (g/mL)')
plt.ylabel('Frequency')
plt.title(f'Monte Carlo simulation (n={n})')
plt.legend()
plt.tight_layout()
plt.show()

# 주의: 입력 분포 가정(여기서는 정규분포)이 틀리면 결과도 틀림
# - 실제 측정값으로 분포 확인 후 가정 변경 가능 (균등, 삼각, 로그정규 등)

import pandas as pd
from datetime import datetime

# 분석 과정에서 한 줄씩 추가
log = pd.DataFrame([
    {
        'date': '2026-05-14',
        'step': 1,
        'purpose': '결측치 점검 코드 작성',
        'ai_model': 'ChatGPT-4',
        'prompt_summary': '결측률 계산 pandas 코드 요청',
        'ai_suggestion': 'isna().sum(), 결측률 계산 코드 제안',
        'my_verification': '원자료 3개 행을 직접 확인해 실제 결측과 일치하는지 검토',
        'revision': '측정 불가로 기록된 NA는 삭제하지 않고 별도 범주로 유지',
        'used_in_report': 'yes'
    },
    {
        'date': '2026-05-15',
        'step': 2,
        'purpose': '회귀분석 코드 검증',
        'ai_model': 'Claude',
        'prompt_summary': '회귀 결과 해석 요청',
        'ai_suggestion': 'R²=0.72라서 강한 관계라고 해석',
        'my_verification': '잔차에 곡선 패턴 발견, 선형 가정 위반 가능성 확인',
        'revision': '2차 다항회귀로 변경, 해석을 "관계"로 표현',
        'used_in_report': 'yes'
    }
])

log.to_csv('ai_usage_log.csv', index=False, encoding='utf-8-sig')
print(log[['date', 'step', 'purpose', 'used_in_report']])

# 보고서에 첨부할 수 있도록 마크다운으로도 출력
print('\n=== 보고서용 요약 ===')
for _, row in log.iterrows():
    print(f"- [{row['date']}] {row['purpose']}")
    print(f"  · AI 제안: {row['ai_suggestion']}")
    print(f"  · 내 검증: {row['my_verification']}")
    print(f"  · 수정: {row['revision']}")