[책 리뷰] 케라스로 구현하는 딥러닝 / 양자인공지능(QAI) 예제

케라스로 구현하는 딥러닝 / 한빛미디어 / 김성진 저 / 정가 30,000원

이 책은 keras 기반의 정말 실용적이고 다양한 딥러닝 모델(ANN, DNN, CNN, RNN, AE, GAN, UNET, RL, QAI)들을 다루고 있다. 실무에는 도움이 많이 될 것으로 보이나, 개인적으로 읽었을 때 기초부터 차근차근 설명해주며 따라가는 느낌이 아니라 이미 알고 있는 machine learning 개념들을 읊으면서 예제들을 빠르게 휙휙 던져주는 구조이기 때문에 딥러닝 초보에게는 추천하지 않는다. 눈에 띄었던 점은 다른 책들과는 다르게 양자인공지능(QAI)을 다루고 있다는 점인데, 아래에서 QAI 간단한 개념 이해를 해보고, 코드 구현을 통해 양자 시뮬레이션을 돌려 보자.

 

---

양자인공지능 개념

양자인공지능(Quantum Artificial Inteligence, QAI)이란, 양자컴퓨터를 이용하여 구현하는 인공지능이며 양자컴퓨터란 양자 효과를 활용하는 컴퓨팅 환경을 말한다. 양자컴퓨터는 양자 중첩(quantum supoerposition)과 양자 얽힘(quantum entanglement) 현상을 이용하여 빠른 계산을 가능하게 한다.

또한, 양자인공지능은 크게 3가지 방식으로 구분된다.

1. 양자계산에 필요한 매개변수를 인공지능 학습에 의해 최적화
2. 양자컴퓨팅을 이용해 전통 인공지능의 계산 속도를 높이는 방법
3. 양자회로를 뉴럴넷과 유사한 형태로 만드는 방법

QAI는 tensorflow quantum등을 통해 지원되며, 내부적으로 양자컴퓨팅은 cirq라는 전용 라이브러리를 활용한다. Cirq는 양자컴퓨터를 위한 프로그래밍 뿐만 아니라 양자컴퓨팅을 시뮬레이션 하는 기능도 제공한다.

나는 양자 컴퓨터가 없는데 어떻게 QAI를 구현하지? 라고 생각했는데 여기에 그 해답이 있었다. 😂😂 시뮬레이터를 이용한 방법을 쓰면 양자컴퓨터가 없어도 알고리즘의 동작을 확인하는 데 문제가 없다. 다만, 계산 속도와 계산 결과에 포함되는 양자 노이즈 특성 등의 시스템 특성은 실제 결과와는 다를 수 있다고 한다.

 

예제 1) 양자컴퓨팅 알고리즘 구현

양자회로의 동작 구조를 cirq, numpy 모듈을 이용하여 simulator를 돌린 예제이다. 양자비트 연산인 NOT, CNOT, bell state를 구현해보고 시뮬레이션을 돌린 후, 측정을 통해 각 양자들의 상태가 어떻게 변화하는지 볼 수 있다.

import cirq

# 1) 양자비트와 양자회로 만들기
``
q = cirq.NamedQubit('My Qubit')
circuit = cirq.Circuit(cirq.measure(q))
print(circuit)

# 만들어진 양자회로를 시뮬레이션을 통해 어떤 결과가 만들어지는지 확인
simulator = cirq.Simulator()
m_outputs = simulator.run(circuit, repetitions=3)
print(m_outputs.measurements)


# 2) 입력을 반전시키는 양자 회로
q = cirq.NamedQubit('My Qubit')
circuit = cirq.Circuit(cirq.X(q), cirq.measure(q))
print(circuit)

simulator = cirq.Simulator()
m_outputs = simulator.run(circuit, repetitions=10)
print(m_outputs.measurements['My Qubit'][:,0])


# 3) 두 상태를 중첩하는 양자회로
import numpy as np

q = cirq.NamedQubit('My Qubit')
circuit = cirq.Circuit(cirq.H(q), cirq.measure(q))
print(circuit)

simulator = cirq.Simulator()
m_outputs = simulator.run(circuit, repetitions=10)
results = m_outputs.measurements['My Qubit'][:,0]
print('Results=',results,' Average=',np.mean(results))

# 충분히 반복하게되면 평균이 0.5에 더 가까워지는지 확인하기 위해 1000번 측정
m_outputs = simulator.run(circuit, repetitions=1000)
results = m_outputs.measurements['My Qubit'][:,0]
print('Average for 100 measurements=',np.mean(results))


# 4) 두 개 양자비트를 위한 계산 예: CNOT 연산
# 두 양자비트의 초기 상태가 |00>인 경우
q = [cirq.GridQubit(i, 0) for i in range(2)]
print(q[0], q[1])

circuit = cirq.Circuit()
circuit.append(cirq.CNOT(q[0], q[1]))
print(circuit)
circuit.append([cirq.measure(q[0]),cirq.measure(q[1])])
print(circuit)

simulator = cirq.Simulator()
m_outputs = simulator.run(circuit, repetitions=10)
print(m_outputs)

# 두 양자비트의 초기 상태가 |10>인 경우
circuit = cirq.Circuit(cirq.X(q[0]))
circuit.append(cirq.CNOT(q[0], q[1]))
circuit.append([cirq.measure(q[0]),cirq.measure(q[1])])
print(circuit)

simulator = cirq.Simulator()
m_outputs = simulator.run(circuit, repetitions=10)
print(m_outputs)


# 5) 벨 상태 만들기
q = [cirq.GridQubit(i, 0) for i in range(2)]
circuit = cirq.Circuit()
circuit.append(cirq.H(q[0]))
print(circuit)
circuit.append(cirq.CNOT(q[0], q[1]))
print(circuit)
circuit.append([cirq.measure(q[0]),cirq.measure(q[1])])
print(circuit)

simulator = cirq.Simulator()
m_outputs = simulator.run(circuit, repetitions=10)
print(m_outputs)

위 코드를 실행하면 아래와 같은 결과를 얻을 수 있다.

$ python -u "c:\Users\yr267\Desktop\kerasapp_2022_for_python38\ex11_1_qai_qc.py"
My Qubit: ───M───
{'My Qubit': array([[0],
       [0],
       [0]], dtype=int8)}
My Qubit: ───X───M───
[1 1 1 1 1 1 1 1 1 1]
My Qubit: ───H───M───
(0, 0): ───H───@───
               │
(1, 0): ───────X───
(0, 0): ───H───@───M───
               │
(1, 0): ───────X───M───
(0, 0)=0110010010
(1, 0)=0110010010

 

예제 2) 하이브리드 양자인공지능 모델링

이제 cirq + tensorflow-quantum으로 양자인공지능을 만들어 보자! (두근두근 🥰🥰)

설치 전에 버전을 잠깐 언급하자면, tensorflow-quantum은 tensorflow v2.1.0과 python 3.6 or 3.7에 대한 의존성을 가지고 있다. 나는 평소 사용하던 3.8을 쓰다가 가상환경을 하나 더 만들어야 했다.. 😂😂

 

본 예제는 Ry 게이트의 매개변수를 학습하고 원하는 값을 찾는 하이브리드 (양자회로 + 전통 인공지능 모델 결합) 양자인공지능 모델을 만드는 예제이다.

참고로 %matplotlib inline 코드는 본인의 vscode conda 환경에서는 동작하지 않아 주석 처리하고 진행하였다.

import tensorflow_quantum as tfq
import cirq
from cirq.contrib.svg import SVGCircuit

import tensorflow as tf
from tensorflow.keras.layers import Dense
from tensorflow.keras import Sequential, Input, Model

import sympy
import numpy as np
%matplotlib inline
import matplotlib.pyplot as plt

## 입력 데이터와 기대 출력 레이블 만들기
X_Classic = np.array([[0], [1]], dtype=np.float32)

Qubit = cirq.GridQubit(0, 0)
Initial_rotation_phase = np.random.uniform(0, 2 * np.pi)
X_Quantum_circuit = cirq.Circuit(
  cirq.ry(Initial_rotation_phase)(Qubit)
)
X_Quantum = tfq.convert_to_tensor(
  [X_Quantum_circuit]*len(X_Classic)) 

Y = np.array([[1], [-1]], dtype=np.float32)

## 전통인공지능 부분 만들기: 파라미터 제어 뉴럴넷
def make_classical_NN(x):
    model = Sequential()
    model.add(Dense(2, activation='relu'))
    model.add(Dense(1))
    return model(x)
Classical_NN_In = Input(shape=(1,), dtype=tf.dtypes.float32, name='commands_input')
Classical_NN = make_classical_NN(Classical_NN_In)

## 파라미터를 포함하는 양자회로 만들기
W = sympy.symbols('W')

Quantum_circuit = cirq.Circuit(cirq.ry(W)(Qubit))
SVGCircuit(Quantum_circuit)

## 하이브리드 인공지능 부분 만들기: 양자 및 전통 인공지능 복합형 
Quantum_In = Input(shape=(),dtype=tf.string, name='circuits_input')
Quantum_layer = tfq.layers.ControlledPQC(Quantum_circuit,
                                          operators = cirq.Z(Qubit))
expectation = Quantum_layer([Quantum_In, Classical_NN])
model = Model(inputs=[Quantum_In, Classical_NN_In],
                       outputs=expectation)

## 모델 학습 및 결과 확인하기
optimizer = tf.keras.optimizers.Adam(learning_rate=0.05)
loss = tf.keras.losses.MeanSquaredError()
model.compile(optimizer=optimizer, loss=loss)
history = model.fit(x=[X_Quantum, X_Classic],
                    y=Y,
                    epochs=50,
                    verbose=0)

plt.plot(history.history['loss'])
plt.title("Training for Quantum-Classic AI")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.grid()
plt.show()

Y_pred = model([X_Quantum, X_Classic]).numpy()
Err = Y - Y_pred
print('Predicted_Y =', Y_pred.flatten()) 
print('Y - Predicted_Y =', Err.flatten())

matplotlib 그래프를 통해 epoch에 따른 loss 그래프를 확인할 수 있다.

Output은 다음과 같다.

$ python -u "c:\Users\yr267\Desktop\kerasapp_2022_for_python38\ex11_3_qai_hybrid.py"
Predicted_Y = [ 0.8855845  -0.99920875]
Y - Predicted_Y = [ 0.11441553 -0.00079125]

 

---

관련 링크

예제 코드는 아래 링크에서 다운받을 수 있다.

https://github.com/jskDr/keraspp_2022

GitHub - jskDr/keraspp_2022: Codes in My Book - Keras

Tensorflow Quantum 논문

https://arxiv.org/abs/2003.02989

TensorFlow Quantum: A Software Framework for Quantum Machine Learning

목차

〈기본 편〉

0장. 프롤로그
__0.1 인공지능과 인공신경망
____0.1.1 인공지능의 역사
____0.1.2 머신러닝과 딥러닝
____0.1.3 인공신경망 개요
__0.2 케라스 소개
____0.2.1 케라스 2의 주요 특징

1장. 케라스 시작하기
__1.1 우분투에서 케라스 설치하기
____1.1.1 아나콘다 파이썬 배포판 설치
____1.1.2 아나콘다를 이용한 케라스 설치
____1.1.3 케라스에서 GPU 사용을 위한 CUDA/cuDNN 설치
__1.2 윈도우에서 케라스 설치하기
____1.2.1 아나콘다 파이썬 배포판 설치
____1.2.2 아나콘다를 이용한 케라스 설치
__1.3 주피터 설치하기
__1.4 케라스 사용하기
____1.4.1 실습 내용 소개
____1.4.2 텍스트 모드 실습
____1.4.3 주피터 모드 실습
__1.5 케라스 기능
__1.6 마치며

2장. 케라스로 구현하는 ANN
__2.1 ANN 원리
____2.1.1 ANN 개념
____2.1.2 ANN 구조
____2.1.3 ANN 활용
____2.1.4 ANN 구현 방법 및 단계
__2.2 필기체를 구분하는 분류 ANN 구현
____2.2.1 분류 ANN을 위한 인공지능 모델 구현
____2.2.2 분류 ANN에 사용할 데이터 가져오기
____2.2.3 분류 ANN 학습 결과의 그래프 구현
____2.2.4 분류 ANN 학습 및 성능 분석
__2.3 결과 데이터를 예측하는 회귀 ANN 구현
____2.3.1 회귀 ANN 모델링
____2.3.2 학습과 평가용 데이터 가져오기
____2.3.3 회귀 ANN 학습 결과 그래프 구현
____2.3.4 회귀 ANN 학습 및 성능 분석
__2.4 마치며

3장. 케라스로 구현하는 DNN
__3.1 DNN 원리
____3.1.1 DNN 개념과 구조
____3.1.2 경사도 소실 문제와 ReLU 활성화 함수
____3.1.3 DNN 구현 단계
__3.2 필기체를 분류하는 DNN 구현
____3.2.1 기본 매개변수 설정
____3.2.2 DNN 모델 구현
____3.2.3 데이터 준비
____3.2.4 학습 및 성능 평가
__3.3 컬러 이미지를 분류하는 DNN 구현
____3.3.1 데이터 가져오기
____3.3.2 DNN 모델링
____3.3.3 학습 효과 분석
____3.3.4 학습 및 성능 평가
__3.4 마치며

4장 케라스로 구현하는 CNN
__4.1 CNN 원리
__4.2 필기체를 분류하는 CNN 구현
____4.2.1 분류 CNN 모델링
____4.2.2 분류 CNN을 위한 데이터 준비
____4.2.3 분류 CNN 학습 효과 분석
____4.2.4 분류 CNN 학습 및 성능 평가
__4.3 컬러 이미지를 분류하는 CNN 구현
____4.3.1 분류 CNN 패키지 가져오기
____4.3.2 분류 CNN 모델링
____4.3.3 분류 CNN을 위한 데이터 준비
____4.3.4 분류 CNN의 학습 및 성능 평가를 위한 머신 클래스
____4.3.5 분류 CNN의 학습 및 성능 평가 수행
__4.4 마치며

5장 케라스로 구현하는 RNN
__5.1 RNN 원리
____5.1.1 RNN의 개념과 구조
____5.1.2 LSTM 구조 및 동작
__5.2 문장을 판별하는 LSTM 구현
____5.2.1 라이브러리 패키지 가져오기
____5.2.2 데이터 준비
____5.2.3 모델링
____5.2.4 학습 및 성능 평가
__5.3 시계열 데이터를 예측하는 LSTM 구현
____5.3.1 라이브러리 패키지 가져오기
____5.3.2 코드 실행 및 결과 보기
____5.3.3 학습하고 평가하기
____5.3.4 LSTM 시계열 데이터 회귀 모델링
____5.3.5 데이터 가져오기
__5.4 마치며

6장 케라스로 구현하는 AE
__6.1 AE 원리
__6.2 완전 연결 계층을 이용한 AE 구현
____6.2.1 완전 연결 계층 AE 모델링
____6.2.2 데이터 준비
____6.2.3 학습 효과 분석
____6.2.4 완전 연결 계층 AE의 동작 확인
____6.2.5 학습 및 성능 평가
__6.3 합성곱 계층을 이용한 AE 구현
____6.3.1 합성곱 AE 모델링
____6.3.2 데이터 준비 및 학습 효과 분석
____6.3.3 합성곱 AE 결과 시각화
____6.3.4 합성곱 AE 학습 및 성능 평가
__6.4 마치며


7장. 케라스로 구현하는 GAN
__7.1 GAN 원리
____7.1.1 GAN의 목적과 개념
____7.1.2 GAN의 구조
____7.1.3 GAN의 동작 원리
____7.1.4 GAN의 동작 사례
__7.2 확률분포 생성을 위한 완전 연결 계층 GAN 구현
____7.2.1 패키지 가져오기
____7.2.2 데이터 생성 클래스 만들기
____7.2.3 GAN 모델링
____7.2.4 머신 구현하기
____7.2.5 코드 수행과 결과 보기
__7.3 필기체를 생성하는 합성곱 계층 GAN 구현
____7.3.1 공통 패키지 가져오기
____7.3.2 사용자 정의 손실 함수 만들기
____7.3.3 합성곱 계층 GAN 모델링
____7.3.4 합성곱 계층 GAN 학습하기
____7.3.5 합성곱 계층 GAN 수행하기
__7.4 마치며

8장 케라스로 구현하는 UNET
__8.1 UNET 원리
__8.2 UNET을 이용한 컬러 복원 처리
____8.2.1 패키지 가져오기
____8.2.2 UNET 모델링
____8.2.3 데이터 준비
____8.2.4 UNET 처리 그래프 그리기
____8.2.5 UNET 학습 및 결과 확인
__8.3 마치며


〈심화 편〉

9장 케라스 확장 기능
__9.1 이미지 데이터 증강하기
____9.1.1 응용 코드 구현
____9.1.2 세부 모듈 구현
__9.2 미리 학습한 모델 사용하기
____9.2.1 응용 코드 구현
____9.2.2 세부 모듈 구현
__9.3 간단한 신규 계층 만들기
____9.3.1 Lambda 계층이란?
____9.3.2 파이썬 Lambda 기능 이용
____9.3.3 Lambda 계층 전용 함수 이용
____9.3.4 백엔드 함수 이용
____9.3.5 엔진 전용 함수 이용
____9.3.6 케라스의 확장 기능 이용
__9.4 학습 가능한 신규 계층 만들기
____9.4.1 관련 패키지 가져오기
____9.4.2 새로운 계층의 클래스 만들기
____9.4.3 사용 데이터 준비하기
____9.4.4 신규 계층이 포함된 모델링 만들기
____9.4.5 모델의 학습과 성능 평가
__9.5 케라스의 확장된 기능 이용하기
____9.5.1 텐서플로 가져오기와 내장 케라스 사용하기
____9.5.2 완전 연결층 인공신경망 모델링
____9.5.3 데이터 준비
____9.5.4 학습 진행 및 효과 분석 단계
____9.5.5 주 함수 구현 및 실행
__9.6 마치며

10장. 케라스로 구현하는 RL
__10.1 강화학습 원리
____10.1.1 강화학습의 정의 및 주요 용어
____10.1.2 강화학습 최적화 기본 방법
__10.2 정책 반복법을 이용하는 강화학습 사례
____10.2.1 Gym을 이용한 강화학습 환경 구성하기
____10.2.2 무작위 행동에 따른 상태, 보상 그리고 종료 여부 관찰하 기
____10.2.3 반환값 구하기
____10.2.4 가치함수 구하기
____10.2.5 행동가치함수 구하기
____10.2.6 새로운 정책 구하기
____10.2.7 새로운 정책 사용하기
__10.3 Q-Learning을 이용하는 강화학습 사례
____10.3.1 패키지 가져오기 및 초기화
____10.3.2 주어진 정책에 따른 시행 함수 만들기
____10.3.3 Q-learning 만들기
____10.3.4 Q-learning 실행하기
__10.4 딥러닝 기반 Q-Learning을 이용하는 강화학습
____10.4.1 관련 패키지 가져오기
____10.4.2 Q 함수를 위한 뉴럴넷 구성하기
____10.4.3 텐서플로 기능을 이용한 Q 함수 뉴럴넷 학습 코드 작성
____10.4.4 객체지향 방식으로 Q 함수 뉴럴넷 모델을 학습시키기
____10.4.5 추가 Q 함수 뉴럴넷 모델을 이용한 학습
____10.4.6 시도와 동시에 학습이 진행되게 만들기
__10.5 마치며

11장. 케라스로 구현하는 QAI
__11.1 양자컴퓨팅과 양자인공지능의 기초
____11.1.1 양자비트 상태 표현과 측정
____11.1.2 단일 양자비트 연산자
____11.1.3 다중 양자비트 표현 및 연산
____11.1.4 블로흐 구면과 지정 양자상태 회전
__11.2 양자컴퓨팅 알고리즘 구현
____11.2.1 기본 양자회로 만들기
____11.2.2 입력을 반전시키는 양자회로
____11.2.3 두 상태를 중첩하는 양자회로
____11.2.4 두 개 양자비트를 입력으로 하는 CNOT 연산
____11.2.5 벨 상태 만들기
__11.3 양자인공지능 알고리즘 구현
____11.3.1 매개변수가 있는 가변양자회로 알고리즘
____11.3.2 하이브리드 양자인공지능 학습하기
__11.4 마치며