📘 인공지능의 이해

1) 역사적 사건

① 최초의 프로그래머 — 에이다 러브레이스 (1815~1852)

• 영국 시인 바이런의 딸. 찰스 배비지의 '해석기관(Analytical Engine)'을 위한 알고리즘을 작성해 세계 최초의 프로그래머로 인정받음.
• 베르누이 수를 구하는 알고리즘 → 최초의 컴퓨터 프로그램으로 간주.
• 서브루틴·조건문(IF)·반복문(Loop) 개념을 앞서 정리.
• 1980년 미국 국방성이 프로그래밍 언어를 Ada로 명명해 업적을 기림.

② 네트워크 — 먼 거리로 메시지 보내기

• 모스 부호: 새뮤얼 모스가 고안, 1844년 볼티모어↔워싱턴 D.C. 전신에 첫 사용.
• 전화: 알렉산더 그레이엄 벨이 1876년 특허. (안토니오 무치가 1849년 유사 장치 개발, 2002년 미국 하원이 공헌 인정 결의)

③ 빅데이터 분석의 시작 — 플로렌스 나이팅게일의 극지역 도표

• 플로렌스 나이팅게일(1820~1910): 크림전쟁 야전병원 데이터를 9개월간 수집.
• 극지역 도표(Coxcomb Chart)로 병사 사망 원인을 시각화 → 정부를 설득해 위생 개선, 사망률 감소.
• 빅데이터의 본질: 규모뿐 아니라 시간 흐름에 따른 추이를 담는 데이터.

④ 인공지능 — 앨런 튜링

▶ 튜링 테스트 (Turing Test)

판정단이 상대가 기계인지 사람인지 구분하지 못하면 '지능 있음'으로 판정. 2014년 '유진 구스트만' 프로그램이 판정단의 33%를 속였다는 주장(논란 있음).

▶ 튜링상 (Turing Award)

ACM이 1966년 제정한 컴퓨터과학 최고 권위상 — '컴퓨터과학의 노벨상'. 앨런 튜링의 이름에서 유래. 존 매카시는 1956년 다트머스 학회에서 처음으로 '인공지능(Artificial Intelligence)'이라는 용어를 사용.

⑤ 스푸트니크 쇼크 (1957)

• 1957.10.4. 소련이 스푸트니크 1호 발사 성공 → 미국 과학·교육계 대충격.
• 미국의 대응: ① NASA 창설(1958) ② ARPANET 개발(1969) — 인터넷의 전신, 최초의 패킷 스위칭 네트워크.

🛰️ 위성, 그때와 지금 · 1957년 스푸트니크 1호(왼쪽) 한 대로 시작한 인공위성이, 오늘날 스타링크(Starlink)(오른쪽) 같은 저궤도 위성 인터넷 군집으로 발전해 오지·바다·하늘까지 지구 전역을 연결한다.

2) IT 기술의 시대별 발전

1) 산업혁명의 구분

4차 산업혁명의 상징 — 알파고 · 구글 딥마인드(창립자 데미스 허사비스)가 만든 바둑 AI. 2016년 3월 이세돌 9단에게 4승 1패로 승리하며 AI 대중 인식의 전환점이 됨.

2) 노동 시장의 양극화

• AI 대체 가능(빈익빈): 택시·버스 기사, 공장 단순 노동, 서빙·간병·청소·조리
• 고부가가치(부익부): 고도 소프트웨어 기술자, 새로운 지식·문화 기반 전문직

3) 자본의 이동 — 글로벌 시가총액 5대 기업

4) 이동통신의 발전

1) 인간의 두뇌 vs 인공 신경망(ANN)

2) AI가 아직 잘 못하는 것

• 깊은 맥락 이해 · 추상적·철학적 개념 · 복잡한 감정 인식 · 모호한 정보 처리 · 일반 상식 추론

3) 인공지능의 역사

🧠 그 이전, 1943년 · 신경생리학자 워런 매컬러(Warren McCulloch)와 논리학자 월터 피츠(Walter Pitts)가 최초의 인공 뉴런 수학 모델(McCulloch–Pitts 뉴런)을 발표했다. "뇌의 뉴런을 논리 회로(AND·OR·NOT)로 나타낼 수 있다"는 이 아이디어가 신경망 연구의 출발점이 되었다.

① 탄생(1952~56) — 1956년 다트머스 컨퍼런스에서 AI 개념 정립(존 매카시·마빈 민스키·앨런 뉴엘·허버트 사이먼).

② 1차 붐(1956~74) — 추리·탐색 — 탐색 트리로 미로·하노이탑 등 문제 해결.

▶ 퍼셉트론 (Perceptron)

미국 심리학자 프랭크 로젠블랫이 1957년 제안. 생물학적 뉴런을 흉내 낸 수학 모델로 딥러닝의 기본 단위. 여러 입력을 가중치로 합쳐 하나의 출력을 낸다.

이후 ELIZA(1966, 최초의 자연어 대화 프로그램), Shakey the Robot(1966~72, 최초의 이동 로봇)이 등장.

③ 1차 암흑기(1974~80) — XOR 논쟁

1969년 마빈 민스키·시모어 페퍼트가 단층 퍼셉트론은 XOR 문제를 풀 수 없다고 지적 → 투자 급감. 해법은 다층 퍼셉트론이었다.

▲ XOR을 푸는 다층 퍼셉트론(MLP) — 은닉 뉴런이 NAND·OR를, 출력 뉴런이 AND를 학습하면 XOR이 풀린다

④ 2차 붐(1980~87) — 지식: 전문가 시스템 등장(의학·법률). 단, 상식 추론 한계로 실패.

⑤ 2차 암흑기(1987~93): 1989년 CNN 등장(얀 르쿤), 1993년 우편번호 인식(LeNet-5) 실용화.

👤 얀 르쿤(Yann LeCun, 1960~) · 프랑스 태생의 컴퓨터 과학자로 CNN(합성곱 신경망)의 창시자다. 1989년 손글씨 숫자 인식을 위한 LeNet을 개발해 은행 수표·우편번호 자동 인식에 실용화했고, 이 CNN 구조가 오늘날 이미지·영상 인식의 토대가 되었다.

• 뉴욕 대학교 교수이자 메타(Meta·옛 페이스북)의 수석 AI 과학자로 AI 연구를 이끈다.
• 2018년 튜링상을 제프리 힌튼·요슈아 벤지오와 공동 수상한 딥러닝 3대 대부의 한 명이다.
• 거대 언어모델(LLM)의 한계를 지적하며, 세계를 스스로 이해하는 월드 모델 등 다음 세대 AI를 주장한다.

⑥ 3차 붐(1994~현재) — 딥러닝: 아래 표 참고.

👤 제프리 힌튼(Geoffrey Hinton, 1947~) · 영국 태생의 인지심리학자·컴퓨터 과학자로 딥러닝의 아버지라 불린다. 신경망이 외면받던 시절에도 연구를 이어가 역전파(backpropagation) 학습법을 널리 알렸고(1986), 2012년 제자들과 만든 AlexNet이 이미지 인식 대회를 압도하며 딥러닝 시대를 열었다.

• 토론토 대학교 교수이자 구글 브레인에서 오래 연구했다.
• 2018년 튜링상(컴퓨터과학의 노벨상)을 얀 르쿤·요슈아 벤지오와 공동 수상 — 셋을 딥러닝 3대 대부라 부른다.
• 2023년 구글을 떠나며 AI의 위험성을 경고해 큰 반향을 일으켰다.
• 2024년 노벨 물리학상을 수상(존 홉필드와 공동) — 신경망의 기초를 세운 공로다.

👤 요슈아 벤지오(Yoshua Bengio, 1964~) · 프랑스 태생의 캐나다 컴퓨터 과학자로, 힌튼·르쿤과 함께 딥러닝을 부활시킨 3대 대부의 한 명이다. 신경망으로 언어를 다루는 연구를 개척해 오늘날 거대 언어모델(LLM)의 밑바탕을 놓았다.

• 몬트리올 대학교 교수이자 세계 최대 딥러닝 연구소 Mila(밀라)의 설립자·소장이다.
• 2000년 단어를 벡터로 표현하는 신경망 언어모델을 제안 — 이후 워드 임베딩과 트랜스포머로 이어졌다.
• 2018년 튜링상을 제프리 힌튼·얀 르쿤과 공동 수상했다.
• 최근에는 AI의 안전과 규제를 강하게 주장하며, 국제 AI 안전성 보고서 작성을 이끌고 있다.

📒 기호주의 vs 연결주의

4) 인공지능의 분류 — ANI · AGI · ASI

📌 레이 커즈와일의 예측(2005 『특이점이 온다』) · AGI 2029년 · ASI(특이점) 2045년. 2024년에도 이 예측을 유지 중이며 전문가들 사이 논쟁이 활발.

5) 인공지능의 윤리와 사회적 영향

AI는 편리함만큼이나 새로운 사회 문제도 함께 가져온다. 기술을 올바르게 쓰기 위한 고민이 곧 AI 윤리다. 크게 공정성·진실성·권리·안전·제도의 축으로 살펴본다.

• 편향(Bias)과 차별: AI는 학습한 데이터를 그대로 닮는다. 과거의 편향된 데이터를 배우면 그대로 차별을 재생산한다. 예) 특정 성별을 낮게 평가한 채용 AI, 유색인종 오인식률이 높았던 안면인식, 특정 계층에 불리한 대출 심사. → 다양한 데이터·공정한 레이블링·알고리즘 감사(audit)가 필요하다.
• 딥페이크(Deepfake)와 허위정보: GAN·생성형 AI로 만든 가짜 영상·음성이 진짜와 구별하기 어려워졌다. 예) 유명인 사칭 보이스피싱, 선거철 가짜 뉴스, 지인 사칭 사기. → 탐지 AI, 콘텐츠에 표식을 남기는 워터마킹, 법 규제로 대응한다.
• 프라이버시와 감시: AI는 대량의 개인정보를 학습·분석한다. 얼굴 추적 CCTV, 행동 예측, 무단 데이터 수집은 사생활 침해가 될 수 있다. → 개인정보 최소 수집, 익명화, 정보 주체의 동의·삭제 요구권이 중요하다.
• 저작권과 창작 윤리: AI 생성물의 저작권은 누구에게 있는지, 창작자 동의 없이 학습에 쓴 데이터가 정당한지가 쟁점이다. 화가·작가·성우들의 소송이 늘고 있다. → 학습 데이터의 출처 투명성과 창작자 보상 체계가 논의된다.
• 일자리와 사회 변화: 단순·반복 업무의 자동화로 일부 직업이 줄지만, 동시에 새로운 직업(AI 관리·데이터·프롬프트 등)도 생긴다. → 평생학습·재교육(리스킬링)과 사회 안전망이 함께 가야 한다.
• AI 안전성과 정렬(Alignment): AI가 의도치 않은 행동을 하거나 악용될 위험. AI의 목표를 인간의 가치와 일치시키는 것이 정렬 문제다. 2023년 영국 블레츨리 파크 AI 안전 정상회의에서 각국이 협력을 약속했다.
• 책임 소재: 자율주행차 사고, 의료 AI 오진처럼 AI가 잘못했을 때 누가 책임지는가(개발사·사용자·AI?)가 아직 명확하지 않다. → 설명 가능한 AI(XAI)와 책임 규정 정비가 필요하다.
• 법·정책: EU AI Act(2024)는 세계 최초의 포괄적 규제법으로 위험 등급별로 AI를 규율한다. 한국도 AI 기본법을 마련하는 등 각국이 제도를 만들고 있다.

1) 인공지능을 만드는 4가지 접근

2) 기계학습(Machine Learning)

기계가 수많은 데이터로 스스로 규칙을 발견하고, 새 데이터에 적용해 예측·분류하는 기술.

3) 딥러닝(Deep Learning)

머신러닝의 한 분야로, 다층 인공신경망을 사용해 복잡한 패턴을 자동으로 학습.

딥러닝 발전의 3대 요소

• 하드웨어: GPU 발전 → 대규모 병렬 처리
• 소프트웨어: TensorFlow·PyTorch·Keras 프레임워크
• 데이터: 빅데이터 시대 → 대규모 학습 데이터 확보

주요 딥러닝 아키텍처

딥러닝의 장단점

• 장점: 복잡한 패턴 자동 학습, 대규모 데이터에서 높은 성능, 특징 추출 자동화
• 단점: 대량 데이터·컴퓨팅 파워 필요, 블랙박스 문제(결정 과정 불투명), 과적합 위험

🔤 LLM의 토큰(Token) — AI가 글을 읽는 '단위'

토큰은 거대언어모델(LLM)이 글을 읽고 쓸 때 다루는 최소 단위이다. 사람은 문장을 단어로 이해하지만, AI는 문장을 잘게 쪼갠 조각(토큰)으로 나눈 뒤, 각 토큰을 번호(정수)로 바꿔 계산한다.

• 자주 쓰는 단어는 한 토큰, 드문 단어는 여러 조각으로 쪼개진다. 예) unbelievable → un + believ + able
• 토큰은 단어일 수도, 조각단어·글자·공백·기호일 수도 있다.
• 한글은 영어보다 토큰을 더 많이 먹는다 — 같은 뜻이라도 한글 문장이 토큰 수가 많아 요금·속도에서 불리할 수 있다.

🐍 파이썬으로 직접 — 토큰 세어보기 (tiktoken)

OpenAI의 실제 토크나이저 tiktoken으로 문장이 몇 토큰인지 확인해보라. 구글 코랩(Colab)에서 !pip install tiktoken 후 그대로 실행된다.

# pip install tiktoken
import tiktoken

# GPT-4o가 사용하는 실제 토크나이저
enc = tiktoken.get_encoding("o200k_base")

samples = [
    "Artificial intelligence is unbelievable",
    "인공지능은 정말 재미있다",
    "strawberry",
]

for text in samples:
    ids = enc.encode(text)                  # 문장 → 토큰 번호 목록
    pieces = [enc.decode([i]) for i in ids] # 각 번호 → 토큰 조각
    print(f"문장     : {text}")
    print(f"토큰 수  : {len(ids)}개")
    print(f"토큰 번호: {ids}")
    print(f"토큰 조각: {pieces}")
    print("-" * 50)

문장     : Artificial intelligence is unbelievable
토큰 수  : 4개
토큰 번호: [186671, 22990, 382, 83614]
토큰 조각: ['Artificial', ' intelligence', ' is', ' unbelievable']
--------------------------------------------------
문장     : 인공지능은 정말 재미있다
토큰 수  : 8개
토큰 번호: [5544, 185890, 19906, 4740, 110308, 193303, 14138, 2276]
토큰 조각: ['인', '공지', '능', '은', ' 정말', ' 재미', '있', '다']
--------------------------------------------------
문장     : strawberry
토큰 수  : 3개
토큰 번호: [302, 1618, 19772]
토큰 조각: ['st', 'raw', 'berry']
--------------------------------------------------

1) 선형회귀 (Scikit-learn) — 키로 몸무게 예측

선형회귀: 알려진 데이터로 알 수 없는 값을 예측. 독립변수 x, 종속변수 y를 직선 y = Wx + b로 모델링한다.

# 한글 폰트 지원 라이브러리 설치 (Colab에서 최초 1회 실행)
!pip install koreanize-matplotlib

# 1. 라이브러리 불러오기
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
import koreanize_matplotlib

# 2. 선형 회귀 모델 생성
regr = LinearRegression()

# 3. 학습 데이터 준비 (키 → 몸무게)
x = [[164], [179], [162], [170], [173]]  # 입력 데이터(키)
y = [53, 63, 55, 59, 68]                 # 출력 데이터(몸무게)

# 4. 모델 학습
regr.fit(x, y)

# 5. 모델 정확도 확인
print("정확도:", regr.score(x, y))

# 6. 새로운 키 데이터 준비
a = [[180], [162], [173]]

# 7. 몸무게 예측
result = regr.predict(a)
print("예측 결과:")
for height, weight in zip(a, result):
    print(f"키 {height[0]}cm → 예상 몸무게 {weight:.1f}kg")

# 8. 결과 시각화
plt.figure(figsize=(8, 6))
plt.scatter(x, y, color='blue', label='실제 데이터')            # 원본 데이터
plt.plot(x, regr.predict(x), color='red', label='회귀선')       # 회귀선
plt.scatter(a, result, color='green', marker='x', s=100, label='예측 데이터')
plt.xlabel('키 (cm)')
plt.ylabel('몸무게 (kg)')
plt.title('키에 따른 몸무게 예측 (선형 회귀)')
plt.legend()
plt.grid(True)
plt.show()

정확도: 0.627529242117842
예측 결과: [66.86680761 54.28964059 61.9756871 ]

▲ 실행 결과 — 키에 따른 몸무게 예측 (파란=실제, 빨강=회귀선, 초록=예측)

2) 신경망 선형회귀 (Keras)

같은 예측을 신경망으로. H(x) = W·x + b의 가중치 W와 편향 b를 학습으로 찾는다.

# 한글 폰트 지원 라이브러리 설치 (Colab에서 최초 1회 실행)
!pip install koreanize-matplotlib

# 1. 라이브러리 불러오기
import koreanize_matplotlib
from keras.models import Sequential
from keras.layers import Dense
import numpy as np

# 데이터 준비
x = np.array([1, 2, 3, 4, 5])
y = np.array([1, 2, 3, 4, 5])

# 모델 구성 (입력층 → 은닉층 → 출력층)
model = Sequential()
model.add(Dense(5, input_dim=1, activation='relu'))  # 입력층 + 은닉층
model.add(Dense(3))                                  # 은닉층
model.add(Dense(1))                                  # 출력층

# 모델 컴파일
model.compile(
    loss='mse',
    optimizer='adam',
    metrics=['mae']   # 회귀는 정확도(acc)가 아니라 mae(평균절대오차)로 평가
)

# 모델 학습
model.fit(x, y, epochs=100, batch_size=1)

▲ 신경망 구조 — 입력층 → 은닉층(5뉴런·ReLU) → 은닉층(3) → 출력층(1)

📌 심화 학습 — 신경망은 이렇게 학습한다

▲ batch_size=1 — 데이터를 하나씩 넣어 오차 계산 → 가중치 갱신 (100에폭 반복)

▲ 뉴런 하나의 계산 — z = w·x + b → ReLU(z) = max(0, z)

3) MNIST 손글씨 숫자 인식 (ANN)

MNIST: 0~9 손글씨 숫자 이미지 70,000개(학습 60,000 + 평가 10,000), 크기 28×28 픽셀. Dense 층만 쓰는 기본 인공신경망(ANN)으로 분류한다.

"""
MNIST 손글씨 숫자 인식 - ANN(인공신경망) 기반
Keras Sequential 모델 사용 (CNN이 아닌 Dense layer만 사용한 기본 ANN)
"""
# 한글 폰트 지원 라이브러리 설치 (Colab에서 최초 1회 실행)
!pip install koreanize-matplotlib

# 1. 라이브러리 불러오기
import koreanize_matplotlib
import numpy as np
import matplotlib.pyplot as plt
from tensorflow import keras
from tensorflow.keras import layers

# 1. 데이터 불러오기
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
print("훈련 데이터 shape:", x_train.shape)   # (60000, 28, 28)
print("테스트 데이터 shape:", x_test.shape)  # (10000, 28, 28)

# 2. 데이터 전처리
# ANN은 1차원 입력을 받으므로 28x28 이미지를 784차원 벡터로 펼침(flatten)
x_train = x_train.reshape(-1, 28 * 28).astype("float32")
x_test = x_test.reshape(-1, 28 * 28).astype("float32")
# 픽셀값(0~255)을 0~1 사이로 정규화
x_train /= 255.0
x_test /= 255.0
# 레이블(0~9)을 원-핫 인코딩으로 변환
num_classes = 10
y_train_cat = keras.utils.to_categorical(y_train, num_classes)
y_test_cat = keras.utils.to_categorical(y_test, num_classes)

# 3. ANN 모델 구성 (Sequential)
model = keras.Sequential([
    layers.Input(shape=(784,)),
    layers.Dense(256, activation="relu"),
    layers.Dropout(0.2),
    layers.Dense(128, activation="relu"),
    layers.Dropout(0.2),
    layers.Dense(num_classes, activation="softmax")
])
model.summary()

# 4. 모델 컴파일
model.compile(
    optimizer="adam",
    loss="categorical_crossentropy",
    metrics=["accuracy"]
)

# 5. 모델 학습
history = model.fit(
    x_train, y_train_cat,
    epochs=15,
    batch_size=128,
    validation_split=0.1,
    verbose=1
)

# 6. 모델 평가
test_loss, test_acc = model.evaluate(x_test, y_test_cat, verbose=0)
print(f"\n테스트 정확도: {test_acc:.4f}")
print(f"테스트 손실: {test_loss:.4f}")

# 7. 학습 곡선 시각화
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(history.history["accuracy"], label="train_acc")
plt.plot(history.history["val_accuracy"], label="val_acc")
plt.title("Accuracy"); plt.xlabel("Epoch"); plt.ylabel("Accuracy"); plt.legend()
plt.subplot(1, 2, 2)
plt.plot(history.history["loss"], label="train_loss")
plt.plot(history.history["val_loss"], label="val_loss")
plt.title("Loss"); plt.xlabel("Epoch"); plt.ylabel("Loss"); plt.legend()
plt.tight_layout(); plt.show()

# 8. 예측 결과 확인 (테스트 샘플 10개)
predictions = model.predict(x_test[:10])
predicted_labels = np.argmax(predictions, axis=1)
plt.figure(figsize=(12, 4))
for i in range(10):
    plt.subplot(2, 5, i + 1)
    plt.imshow(x_test[i].reshape(28, 28), cmap="gray")
    correct = predicted_labels[i] == y_test[i]
    color = "green" if correct else "red"
    plt.title(f"예측:{predicted_labels[i]} / 실제:{y_test[i]}", color=color, fontsize=9)
    plt.axis("off")
plt.tight_layout(); plt.show()

# 9. 모델 저장 (선택)
model.save("mnist_ann_model.keras")
print("모델이 'mnist_ann_model.keras' 로 저장되었습니다.")

③ 모델 구조

▲ Sequential ANN 모델 구조 (784 → Dense 256 → 128 → Softmax 10)

④ 신경망 데이터 흐름

▲ 784차원 벡터가 층을 지나며 특징이 압축·추상화되고, 마지막 softmax가 "숫자 7일 확률 91%"로 답한다

⑤ 신경망 계층 연산 플로우차트

▲ 각 계층의 연산 흐름 (입력 → 가중치·편향 → 활성화 → 다음 층)

4) Fashion MNIST (CNN)

Fashion MNIST: 옷·신발 등 10종 이미지 분류. CNN(합성곱 신경망)으로 구현 — Conv2D/MaxPooling이 왜 필요한지 ANN과 비교해 보라.

CNN 구조 · 입력(28×28×1) → Conv2D(32)+MaxPool → Conv2D(64)+MaxPool → Conv2D(128) → Flatten → Dense(128) → 출력(10). 특징맵은 28→14→7로 줄고 채널은 32→64→128로 늘어난다 — "공간은 압축, 특징은 다양하게".

"""
Fashion MNIST 이미지 분류 - CNN(합성곱 신경망) 기반
Keras Sequential 모델 사용 (Conv2D + MaxPooling2D + Dense)
패션 이미지 10종 분류 (T-shirt, Trouser, Pullover, Dress, Coat,
                       Sandal, Shirt, Sneaker, Bag, Ankle boot)
"""
# 한글 폰트 지원 라이브러리 설치 (Colab에서 최초 1회 실행)
!pip install koreanize-matplotlib

# 1. 라이브러리 불러오기
import koreanize_matplotlib
import numpy as np
import matplotlib.pyplot as plt
from tensorflow import keras
from tensorflow.keras import layers

# 1. 데이터 불러오기
(x_train, y_train), (x_test, y_test) = keras.datasets.fashion_mnist.load_data()
class_names = ["T-shirt/top", "Trouser", "Pullover", "Dress", "Coat",
               "Sandal", "Shirt", "Sneaker", "Bag", "Ankle boot"]

# 2. 데이터 전처리
# CNN은 (배치, 높이, 너비, 채널) 형태의 4차원 입력을 받음 (흑백이라 채널 1)
x_train = x_train.reshape(-1, 28, 28, 1).astype("float32") / 255.0
x_test = x_test.reshape(-1, 28, 28, 1).astype("float32") / 255.0
num_classes = 10
y_train_cat = keras.utils.to_categorical(y_train, num_classes)
y_test_cat = keras.utils.to_categorical(y_test, num_classes)

# 3. CNN 모델 구성 (Sequential)
model = keras.Sequential([
    layers.Input(shape=(28, 28, 1)),
    # 첫 번째 합성곱 블록: 지역적인 특징(모서리, 선) 추출
    layers.Conv2D(32, kernel_size=(3, 3), activation="relu", padding="same"),
    layers.MaxPooling2D(pool_size=(2, 2)),  # 28x28 -> 14x14
    # 두 번째 합성곱 블록: 더 추상적인 특징(모양, 패턴) 추출
    layers.Conv2D(64, kernel_size=(3, 3), activation="relu", padding="same"),
    layers.MaxPooling2D(pool_size=(2, 2)),  # 14x14 -> 7x7
    # 세 번째 합성곱 블록
    layers.Conv2D(128, kernel_size=(3, 3), activation="relu", padding="same"),
    layers.Flatten(),                       # 2차원 특징맵 → 1차원
    layers.Dense(128, activation="relu"),
    layers.Dropout(0.3),
    layers.Dense(num_classes, activation="softmax")
])
model.summary()

# 4. 모델 컴파일
model.compile(optimizer="adam",
              loss="categorical_crossentropy",
              metrics=["accuracy"])

# 5. 모델 학습
history = model.fit(x_train, y_train_cat, epochs=15, batch_size=128,
                    validation_split=0.1, verbose=1)

# 6. 모델 평가
test_loss, test_acc = model.evaluate(x_test, y_test_cat, verbose=0)
print(f"\n테스트 정확도: {test_acc:.4f}")

# 7. 예측 결과 확인 (테스트 샘플 10개)
predictions = model.predict(x_test[:10])
predicted_labels = np.argmax(predictions, axis=1)
plt.figure(figsize=(14, 5))
for i in range(10):
    plt.subplot(2, 5, i + 1)
    plt.imshow(x_test[i].reshape(28, 28), cmap="gray")
    correct = predicted_labels[i] == y_test[i]
    color = "green" if correct else "red"
    plt.title(f"예측:{class_names[predicted_labels[i]]}\n실제:{class_names[y_test[i]]}",
              color=color, fontsize=8)
    plt.axis("off")
plt.tight_layout(); plt.show()

# 8. 모델 저장 (선택)
model.save("fashion_mnist_cnn_model.keras")

모델 구조

▲ CNN 모델 구조 — 파랑=학습층(Conv2D·Dense), 청록=MaxPooling, 주황=Dropout

# 3번 실습에서 저장한 MNIST 모델을 불러온다
# (새 세션이라 파일이 없으면 여기서 바로 간단히 학습한다 · 약 30초)
import os
from tensorflow.keras.models import load_model
from google.colab import output
from IPython.display import HTML, display
from base64 import b64decode
from PIL import Image
import numpy as np, io

if not os.path.exists("mnist_ann_model.keras"):
    from tensorflow import keras
    from tensorflow.keras import layers
    (X, y), _ = keras.datasets.mnist.load_data()
    X = X.reshape(-1, 784).astype("float32") / 255.0
    m = keras.Sequential([
        layers.Input(shape=(784,)),
        layers.Dense(256, activation="relu"),
        layers.Dense(128, activation="relu"),
        layers.Dense(10, activation="softmax"),
    ])
    m.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])
    m.fit(X, y, epochs=3, verbose=0)
    m.save("mnist_ann_model.keras")

model = load_model("mnist_ann_model.keras")

# [예측] 버튼을 누르면 호출되는 함수 (그림을 받아 숫자를 맞힌다)
def predict_digit(data_url):
    # 1) 캔버스 그림을 흑백 배열로 (흰 글씨 · 검은 배경)
    img = Image.open(io.BytesIO(b64decode(data_url.split(',')[1]))).convert("L")
    arr = np.array(img)

    # 2) 그린 부분(글씨)의 경계 상자만 잘라낸다
    ys, xs = np.where(arr > 30)
    if len(xs) == 0:
        print("먼저 숫자를 그려주세요.")
        return
    arr = arr[ys.min():ys.max() + 1, xs.min():xs.max() + 1]

    # 3) MNIST처럼 긴 변을 20px로 맞춰 28x28 한가운데에 넣는다
    h, w = arr.shape
    s = 20.0 / max(h, w)
    digit = Image.fromarray(arr).resize((max(1, int(w * s)), max(1, int(h * s))))
    canvas28 = Image.new("L", (28, 28), 0)
    canvas28.paste(digit, ((28 - digit.width) // 2, (28 - digit.height) // 2))

    # 4) 모델 입력 형태로 변환해 예측
    x = np.array(canvas28).reshape(1, 784) / 255.0
    pred = model.predict(x, verbose=0)
    print(f"AI 예측: {pred.argmax()}  (확신도 {pred.max():.0%})")

# 위 함수를 자바스크립트에서 부를 수 있도록 등록
output.register_callback("digit.predict", predict_digit)

# 마우스로 숫자를 그리는 캔버스 ([예측] 맞히기 · [지우기] 다시 그리기)
canvas = """
<canvas id="cv" width=200 height=200 style="border:2px solid #333"></canvas><br>
<button onclick="predict()">예측</button>
<button onclick="clr()">지우기</button>
<script>
var c=document.getElementById('cv'), x=c.getContext('2d'), draw=false;
function clr(){x.fillStyle='black'; x.fillRect(0,0,200,200);}
clr(); x.strokeStyle='white'; x.lineWidth=14; x.lineCap='round';
c.onmousedown=e=>{draw=true; x.beginPath(); x.moveTo(e.offsetX,e.offsetY);};
c.onmousemove=e=>{if(draw){x.lineTo(e.offsetX,e.offsetY); x.stroke();}};
c.onmouseup=()=>draw=false;
function predict(){ google.colab.kernel.invokeFunction('digit.predict', [c.toDataURL()], {}); }
</script>
"""

# 셀은 여기서 바로 끝난다. 이후 [예측]을 누를 때마다 결과가 아래에 찍힌다 (지우고 반복 가능)
display(HTML(canvas))

AI 예측: 7  (확신도 98%)
AI 예측: 3  (확신도 95%)
AI 예측: 0  (확신도 99%)

# MobileNetV2 : 이미 1000종의 사물을 학습해 둔 모델 (학습 0초!)
from tensorflow.keras.applications.mobilenet_v2 import (
    MobileNetV2, preprocess_input, decode_predictions)
from tensorflow.keras.preprocessing import image
from google.colab import files
import numpy as np

model = MobileNetV2(weights="imagenet")

up = files.upload()                       # 내 사진 업로드 (강아지, 음식, 물건...)
fname = list(up.keys())[0]

# 사진을 224x224 로 맞춰 모델에 넣는다
img = image.load_img(fname, target_size=(224, 224))
x = preprocess_input(np.expand_dims(image.img_to_array(img), 0))
pred = model.predict(x)

# 가장 그럴듯한 후보 3개 출력
for _, label, prob in decode_predictions(pred, top=3)[0]:
    print(f"{label:22s} {prob:.1%}")

golden_retriever       92.4%
Labrador_retriever      4.1%
tennis_ball             1.3%

!pip -q install transformers

from transformers import pipeline

# 한국어 문장의 긍정/부정을 판별하는 사전학습 모델
sentiment = pipeline("sentiment-analysis",
                     model="matthewburke/korean_sentiment")

문장들 = ["이 영화 진짜 재미있었어요!",
        "시간이 아까운 영화네요",
        "배우 연기는 좋았지만 스토리가 조금 아쉽다"]

for 문장 in 문장들:
    r = sentiment(문장)[0]
    감정 = "긍정 😊" if r["label"].endswith("1") else "부정 😞"
    print(f"{문장}  ->  {감정} ({r['score']:.0%})")

이 영화 진짜 재미있었어요!            ->  긍정 😊 (98%)
시간이 아까운 영화네요               ->  부정 😞 (95%)
배우 연기는 좋았지만 스토리가 조금 아쉽다  ->  부정 😞 (74%)

import tensorflow_hub as hub
import tensorflow as tf

# TensorFlow Hub 의 사전학습된 '스타일 변환' 모델
model = hub.load("https://tfhub.dev/google/magenta/"
                 "arbitrary-image-stylization-v1-256/2")

def load(path):
    img = tf.io.decode_image(tf.io.read_file(path), channels=3)
    img = tf.image.convert_image_dtype(img, tf.float32)
    return img[tf.newaxis, :]

content = load("my_photo.jpg")     # 내 사진
style = load("gogh.jpg")           # 고흐 '별이 빛나는 밤'

result = model(content, style)[0]  # 사진에 화풍을 입힌다

tf.keras.utils.array_to_img(result[0]).save("art.png")
print("완성! 'art.png' 저장 — 내 사진이 명화 화풍으로 바뀌었다 🎨")

완성! 'art.png' 저장 — 내 사진이 명화 화풍으로 바뀌었다 🎨

1) 사회적 변화

• 기술·자본을 가진 소수 엘리트에게 권력 집중 심화.
• 기존 산업혁명과 달리 새 일자리가 충분히 안 생길 수 있음 → 적극적 사회 안전망 필요.

2) 인간 영역의 변화

• 대중교통·음악 창작·정책·법률 등 다양한 분야에 AI 적용.
• 글쓰기·번역·코딩·진단 등 인지 영역까지 진입 → 인간-AI 협업 모델 필요.

3) 특이점(Singularity) 논의

• 감정·창의성·도덕적 판단 영역에도 AI 등장 가능성 논의 중.
• 커즈와일: 2045년 ASI 등장 → 인간과 기계의 융합 예측.

수학 원리를 직접 만져보고 싶다면 → 🧮 AI 수학 강의 로 이어서 학습하라.