케라스 튜토리얼: 케라스란 무엇인가요? Python으로 설치하는 방법 [예제]

케라스란 무엇인가요?

케 라스 Theano 또는 Tensorflow 위에서 실행되는 Python으로 작성된 오픈 소스 신경망 라이브러리입니다. 모듈식으로 빠르고 사용하기 쉽게 설계되었습니다. Google 엔지니어인 François Chollet이 개발했습니다. Keras는 낮은 수준의 계산을 처리하지 않습니다. 대신에 "백엔드"라는 다른 라이브러리를 사용하여 이를 수행합니다.

Keras는 TensorFlow, CNTK 또는 Theano 위에서 실행될 수 있는 하위 수준 API를 위한 상위 수준 API 래퍼입니다. Keras 고급 API는 모델을 만들고, 레이어를 정의하고, 여러 입출력 모델을 설정하는 방식을 처리합니다. 이 수준에서 Keras는 손실 및 최적화 기능, 학습 프로세스를 맞춤 기능으로 모델을 컴파일합니다. Python의 Keras는 "백엔드" 엔진에서 처리했기 때문에 계산 그래프 만들기, 텐서 또는 기타 변수 만들기와 같은 저수준 API를 처리하지 않습니다.

백엔드란 무엇입니까?

백엔드는 Tensorflow나 Theano와 같은 다른 라이브러리의 도움을 받아 텐서 곱, 컨볼루션 및 기타 여러 가지 작업과 같은 모든 하위 수준 계산을 수행하는 Keras의 용어입니다. 따라서 "백엔드 엔진"은 모델의 계산 및 개발을 수행합니다. Tensorflow는 기본 "백엔드 엔진"이지만 구성에서 변경할 수 있습니다.

Theano, Tensorflow 및 CNTK 백엔드

Theano의 백엔드

Theano는 캐나다 퀘벡주 몬트리올 대학의 MILA 그룹이 개발한 오픈 소스 프로젝트입니다. 이는 널리 사용되는 최초의 프레임워크였습니다. Numpy 또는 Scipy를 사용하여 수학 연산을 위한 다차원 배열을 돕는 Python 라이브러리입니다. Theano는 더 빠른 계산을 위해 GPU를 사용할 수 있으며, 기울기 계산을 위한 기호 그래프를 자동으로 구축할 수도 있습니다. 웹사이트에서 Theano는 수치적으로 불안정한 표현식을 인식하고 보다 안정적인 알고리즘으로 계산할 수 있다고 주장합니다. 이는 불안정한 표현식에 매우 유용합니다.

TensorFlow의 백엔드

반면, Tensorflow는 딥러닝 프레임워크의 떠오르는 별입니다. Google의 Brain 팀이 개발한 이 도구는 가장 인기 있는 딥 러닝 도구입니다. 많은 기능을 통해 연구원들은 딥 러닝 목적을 위한 이 프레임워크를 개발하는 데 기여하고 있습니다.

CNTK의 백엔드

Keras의 또 다른 백엔드 엔진은 The Microsoft 인지 툴킷 또는 CNTK. 에서 개발한 오픈소스 딥러닝 프레임워크입니다. Microsoft 팀. 대규모 딥 러닝 모델을 훈련하기 위해 다중 GPU 또는 다중 머신에서 실행할 수 있습니다. 경우에 따라 CNTK는 Tensorflow 또는 Theano와 같은 다른 프레임워크보다 빠르게 보고되었습니다. 다음 Keras CNN 튜토리얼에서는 Theano, TensorFlow 및 CNTK의 백엔드를 비교해 보겠습니다.

백엔드 비교

이 두 백엔드 간의 비교를 확인하려면 벤치마크를 수행해야 합니다. 에서 볼 수 있듯이 이정윤의 벤치마크, 서로 다른 하드웨어에서 서로 다른 3가지 백엔드의 성능을 비교합니다. 그 결과 Theano가 다른 백엔드보다 느리다는 것이 보고되었습니다. 50 시간 속도는 느리지만 정확도는 서로 비슷합니다.

다른 벤치마크 테스트 에 의해 수행된다 자스미트 바티아. 그는 일부 테스트에서 Theano가 Tensorflow보다 느리다고 보고했습니다. 그러나 전반적인 정확도는 테스트된 모든 네트워크에서 거의 동일합니다.

따라서 Theano, Tensorflow 및 CTK 중에서 TensorFlow가 Theano보다 낫다는 것은 명백합니다. TensorFlow를 사용하면 계산 시간이 훨씬 짧고 CNN이 다른 것보다 좋습니다.

다음으로 Keras Python 튜토리얼에서는 Keras와 TensorFlow(케라스 vs 텐서플로우).

케라스 vs 텐서플로우

파라미터 케 라스 텐서 플로우
타입 고급 API 래퍼 저수준 API
와plexity Python 언어를 사용하는 경우 사용하기 쉽습니다. Tensorflow 함수 중 일부를 사용하는 구문을 배워야 합니다.
목적 표준 레이어로 모델을 만들기 위한 신속한 배포 임의의 계산 그래프 또는 모델 레이어를 만들 수 있습니다.
도구 TFDBG와 같은 다른 API 디버그 도구를 사용합니다. Tensorboard 시각화 도구를 사용할 수 있습니다
커뮤니티 대규모 활성 커뮤니티 대규모 활성 커뮤니티 및 널리 공유되는 리소스

케라스의 장점

빠른 배포 및 이해하기 쉬움

Keras는 네트워크 모델을 만드는 데 매우 빠릅니다. 몇 줄로 간단한 네트워크 모델을 만들고 싶다면 Python Keras가 도움이 될 수 있습니다. 아래 Keras 예제를 살펴보세요.

from keras.models import Sequential
from keras.layers import Dense, Activation

model = Sequential()
model.add(Dense(64, activation='relu', input_dim=50)) #input shape of 50
model.add(Dense(28, activation='relu')) #input shape of 50
model.add(Dense(10, activation='softmax'))

API가 친숙하기 때문에 프로세스를 쉽게 이해할 수 있습니다. 여러 매개변수를 설정할 필요 없이 간단한 함수로 코드를 작성합니다.

대규모 커뮤니티 지원

딥러닝 프레임워크에 Keras를 사용하는 AI 커뮤니티가 많이 있습니다. 그들 중 다수는 자신의 코드와 튜토리얼을 일반 대중에게 공개합니다.

여러 백엔드 보유

Keras를 사용하면 Tensorflow, CNTK 및 Theano를 백엔드로 선택할 수 있습니다. 필요에 따라 프로젝트마다 다른 백엔드를 선택할 수 있습니다. 각 백엔드에는 고유한 장점이 있습니다.

크로스 플랫폼 및 간편한 모델 배포

다양한 지원 장치와 플랫폼을 통해 다음과 같은 모든 장치에 Keras를 배포할 수 있습니다.

  • CoreML을 사용하는 iOS
  • Tensorflow를 사용하는 Android Android,
  • .js를 지원하는 웹 브라우저
  • 클라우드 엔진
  • 라즈베리 파이

다중 GPU 지원

단일 GPU에서 Keras를 훈련시키거나 한 번에 여러 GPU를 사용할 수 있습니다. Keras에는 데이터 병렬 처리 기능이 내장되어 있어 대량의 데이터를 처리하고 훈련에 필요한 시간을 단축할 수 있기 때문입니다.

케라스의 단점

낮은 수준의 API를 처리할 수 없습니다

Keras는 Tensorflow, Theano 또는 CNTK와 같은 다른 프레임워크나 백엔드 엔진에서 실행되는 상위 수준 API만 처리합니다. 따라서 Keras에는 이미 사전 구성된 레이어가 있기 때문에 연구 목적으로 자신만의 추상 레이어를 만들려는 경우 그다지 유용하지 않습니다.

케라스 설치

이번 섹션에서는 Keras를 설치하는 데 사용할 수 있는 다양한 방법을 살펴보겠습니다.

직접 설치 또는 가상 환경

어느 것이 더 낫습니까? 현재 Python에 직접 설치하시겠습니까, 아니면 가상 환경을 사용하시겠습니까? 프로젝트가 많은 경우 가상 환경을 사용하는 것이 좋습니다. 이유를 알고 싶으십니까? 이는 서로 다른 프로젝트가 서로 다른 버전의 keras 라이브러리를 사용할 수 있기 때문입니다.

예를 들어, 이전 Keras-Theano 백엔드와 함께 OpenCV 3.5을 사용하여 Python 3.3가 필요한 프로젝트가 있지만 다른 프로젝트에서는 최신 버전의 Keras와 Python 3.6.6 지원이 포함된 백엔드인 Tensorflow를 사용해야 합니다.

우리는 Keras 라이브러리가 서로 충돌하는 것을 원하지 않습니다. 그렇죠? 따라서 우리는 가상 환경을 사용하여 특정 유형의 라이브러리로 프로젝트를 현지화하거나 클라우드 서비스와 같은 다른 플랫폼을 사용하여 다음과 같은 계산을 수행할 수 있습니다. Amazon 웹 서비스.

Keras 설치 Amazon 웹 서비스(AWS)

Amazon 웹 서비스는 연구자 또는 기타 목적을 위해 클라우드 컴퓨팅 서비스 및 제품을 제공하는 플랫폼입니다. AWS는 하드웨어, 네트워킹, 데이터베이스 등을 임대하여 인터넷에서 직접 사용할 수 있습니다. 딥러닝 목적으로 인기 있는 AWS 서비스 중 하나는 Amazon 머신 이미지 딥 러닝 서비스 또는 DL

AWS 사용 방법에 대한 자세한 지침은 다음을 참조하세요. 지도 시간

AMI에 대한 참고 사항: 다음과 같은 내용이 제공됩니다.wing AMI 사용 가능

AWS에 케라스 설치하기

AWS Deep Learning AMI는 연구원이나 실무자가 딥 러닝 작업을 수행하는 데 도움이 되는 AWS EC2 서비스의 가상 환경입니다. DLAMI는 소형 CPU 엔진부터 사전 구성된 CUDA, cuDNN을 갖춘 고성능 멀티 GPU 엔진까지 제공하며 다양한 딥 러닝 프레임워크와 함께 제공됩니다.

즉시 사용하려면 널리 사용되는 딥 러닝 프레임워크가 사전 설치되어 제공되는 Deep Learning AMI를 선택해야 합니다.

그러나 연구를 위해 사용자 지정 딥 러닝 프레임워크를 사용하려면 CUDA, cuDNN, GPU 드라이버 및 기타 딥 러닝 환경에서 실행하는 데 필요한 라이브러리와 같은 기본 라이브러리가 함께 제공되므로 Deep Learning Base AMI를 설치해야 합니다.

Keras를 설치하는 방법 Amazon 세이지 메이커

Amazon SageMaker는 최고의 알고리즘을 사용하여 딥 러닝 네트워크를 훈련하고 배포하는 데 도움을 주는 딥 러닝 플랫폼입니다.

초보자에게는 이것이 Keras를 사용하는 가장 쉬운 방법입니다. 다음은 Keras를 설치하는 과정입니다. Amazon 세이지메이커:

1단계) 열기 Amazon 세이지 메이커

첫 번째 단계에서는 다음을 엽니다. Amazon 현인 콘솔을 열고 노트북 인스턴스 생성을 클릭합니다.

케라스를 설치하세요 Amazon 세이지 메이커

2단계) de를 입력하세요.tails

  1. 노트북 이름을 입력하세요.
  2. IAM 역할을 생성합니다. AMI 역할이 생성됩니다. Amazon 다음 형식의 IAM 역할 AmazonSageMaker-실행역할-YYYYMMDD|HHmmSS.
  3. 마지막으로 노트북 인스턴스 생성을 선택합니다. 잠시 후, Amazon Sagemaker가 노트북 인스턴스를 시작합니다.

케라스를 설치하세요 Amazon 세이지 메이커

주의 사항: VPC의 리소스에 액세스하려면 직접 인터넷 액세스를 활성화로 설정하세요. 다른wise, 이 노트북 인스턴스는 인터넷에 액세스할 수 없으므로 모델을 교육하거나 호스팅할 수 없습니다.

3단계) ​​인스턴스 시작

열기를 클릭하여 인스턴스를 시작합니다.

케라스를 설치하세요 Amazon 세이지 메이커

4단계) 코딩 시작

In Jupyter, New> conda_tensorflow_p36을 클릭하면 코딩 준비가 완료됩니다.

케라스를 설치하세요 Amazon 세이지 메이커

리눅스에 케라스 설치하기

Tensorflow를 백엔드 엔진으로 사용하여 Keras를 활성화하려면 먼저 Tensorflow를 설치해야 합니다. CPU(GPU 없음)와 함께 tensorflow를 설치하려면 이 명령을 실행하세요.

pip install --upgrade tensorflow

텐서플로우에 대한 GPU 지원을 활성화하려면 이 명령을 사용할 수 있습니다

pip install --upgrade tensorflow-gpu

Linux에 케라스 설치

Python에서 다음을 입력하여 설치가 성공했는지 확인해 보겠습니다.

user@user:~$ python
Python 3.6.4 (default, Mar 20 2018, 11:10:20) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import tensorflow
>>>

오류 메시지가 없으면 설치 프로세스가 성공한 것입니다.

케라스 설치

Tensorflow를 설치한 후 keras 설치를 시작하겠습니다. 터미널에 이 명령을 입력하세요

pip install keras

Keras와 모든 종속 항목 설치가 시작됩니다. 다음과 같은 내용이 표시됩니다.

케라스 설치

이제 시스템에 Keras가 설치되었습니다!

확인 중

Keras를 사용하기 전에 구성 파일을 열어 Keras가 Tensorflow를 백엔드로 사용하는지 확인해야 합니다.

gedit ~/.keras/keras.json

당신은 이것과 같은 것을보아야합니다

{
    "floatx": "float32",
    "epsilon": 1e-07,
    "backend": "tensorflow",
    "image_data_format": "channels_last"
}

보시다시피 "백엔드"는 tensorflow를 사용합니다. 이는 keras가 예상한 대로 Tensorflow를 백엔드로 사용하고 있음을 의미합니다.

이제 터미널에서 다음을 입력하여 실행하세요.

user@user:~$ python3
Python 3.6.4 (default, Mar 20 2018, 11:10:20) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import keras
Using TensorFlow backend.
>>> 

Keras를 설치하는 방법 Windows

설치하기 전에 텐서 플로우 그리고 Keras를 사용하려면 Python, pip, virtualenv를 설치해야 합니다. 이러한 라이브러리를 이미 설치한 경우 다음 단계를 계속 진행해야 합니다.wise 이 작업을 수행:

여기에서 다운로드하여 Python 3를 설치하세요. 링크

다음을 실행하여 pip를 설치하세요.

이 명령으로 virtualenv를 설치하십시오.

pip3 install –U pip virtualenv

설치 Microsoft Visual C++ 2015 재배포 가능 업데이트 3

그런 다음 이 스크립트를 실행하세요.

pip3 install virtualenv

가상 환경 설정

이는 작업 시스템을 기본 시스템과 분리하는 데 사용됩니다.

virtualenv –-system-site-packages –p python3 ./venv

환경 활성화

.\venv\Scripts\activate

환경을 준비한 후에도 Tensorflow 및 Keras 설치는 Linux와 동일하게 유지됩니다. 다음으로 Keras를 사용한 딥 러닝 튜토리얼에서는 딥 러닝을 위한 Keras 기본 사항에 대해 알아봅니다.

딥 러닝을 위한 Keras 기초

Keras의 주요 구조는 네트워크의 전체 그래프를 정의하는 모델입니다. 기존 모델에 더 많은 레이어를 추가하여 프로젝트에 필요한 사용자 정의 모델을 구축할 수 있습니다.

순차적 모델을 만드는 방법과 딥 러닝에서 일반적으로 사용되는 몇 가지 레이어는 다음과 같습니다.

1. 순차 모델

from keras.models import Sequential
from keras.layers import Dense, Activation,Conv2D,MaxPooling2D,Flatten,Dropout

model = Sequential()

2. 컨볼루션 레이어

이것은 입력 형태가 320x320x3이고 크기가 48×3인 3개의 필터가 있는 입력 레이어인 컨벌루션 레이어의 Keras Python 예이며 ReLU를 활성화 함수로 사용합니다.

input_shape=(320,320,3) #this is the input shape of an image 320x320x3
model.add(Conv2D(48, (3, 3), activation='relu', input_shape= input_shape))

또 다른 유형은

model.add(Conv2D(48, (3, 3), activation='relu'))

3. 최대Pooling 레이어

입력 표현을 다운샘플링하려면 MaxPool2d를 사용하고 커널 크기를 지정하십시오.

model.add(MaxPooling2D(pool_size=(2, 2)))

4. 조밀층

출력 크기만 지정하여 완전 연결 레이어 추가

model.add(Dense(256, activation='relu'))

5. 드롭아웃 레이어

50% 확률로 드롭아웃 레이어 추가

model.add(Dropout(0.5))

컴파일, 훈련, 평가

모델을 정의한 후 학습을 시작하겠습니다. 먼저 손실 함수와 최적화 함수를 사용하여 네트워크를 컴파일해야 합니다. 이를 통해 네트워크의 가중치를 변경하고 손실을 최소화할 수 있습니다.

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

이제 훈련을 시작하려면 fit을 사용하여 훈련 및 검증 데이터를 모델에 공급하십시오. 이를 통해 네트워크를 일괄적으로 훈련하고 에포크를 설정할 수 있습니다.

model.fit(X_train, X_train, batch_size=32, epochs=10, validation_data=(x_val, y_val))

마지막 단계는 테스트 데이터로 모델을 평가하는 것입니다.

score = model.evaluate(x_test, y_test, batch_size=32)

간단한 선형 회귀를 사용해 보겠습니다.

import keras
from keras.models import Sequential
from keras.layers import Dense, Activation
import numpy as np
import matplotlib.pyplot as plt 
 
x = data = np.linspace(1,2,200)
y = x*4 + np.random.randn(*x.shape) * 0.3


model = Sequential()
model.add(Dense(1, input_dim=1, activation='linear'))

model.compile(optimizer='sgd', loss='mse', metrics=['mse'])

weights = model.layers[0].get_weights()
w_init = weights[0][0][0]
b_init = weights[1][0]
print('Linear regression model is initialized with weights w: %.2f, b: %.2f' % (w_init, b_init)) 


model.fit(x,y, batch_size=1, epochs=30, shuffle=False)

weights = model.layers[0].get_weights()
w_final = weights[0][0][0]
b_final = weights[1][0]
print('Linear regression model is trained to have weight w: %.2f, b: %.2f' % (w_final, b_final))

predict = model.predict(data)

plt.plot(data, predict, 'b', data , y, 'k.')
plt.show()

데이터를 훈련한 후 출력은 다음과 같아야 합니다.

선형 회귀

초기 무게로

Linear regression model is initialized with weights w: 0.37, b: 0.00

그리고 최종 무게

Linear regression model is trained to have weight w: 3.70, b: 0.61

Keras에서 사전 학습된 모델을 미세 조정하고 사용하는 방법

Fine Tune Model을 사용하는 이유와 사용 시기

미세 조정은 매개변수가 새 모델에 적응되도록 사전 훈련된 모델을 조정하는 작업입니다. 새로운 모델을 처음부터 훈련하려면 네트워크가 모든 매개변수를 찾을 수 있도록 많은 양의 데이터가 필요합니다. 하지만 이 경우 사전 훈련된 모델을 사용하므로 매개변수가 이미 학습되고 가중치가 부여됩니다.

예를 들어, 분류 문제를 해결하기 위해 자체 Keras 모델을 훈련하고 싶지만 데이터 양이 적다면 다음을 사용하여 이를 해결할 수 있습니다. 전학 학습 + 미세 조정 방법.

사전 훈련된 네트워크와 가중치를 사용하면 전체 네트워크를 훈련할 필요가 없습니다. 우리는 이를 Fine-Tuning 방법이라고 부르므로 작업을 해결하는 데 사용되는 마지막 레이어만 훈련하면 됩니다.

네트워크 모델 준비

사전 훈련된 모델의 경우 Keras가 라이브러리에 이미 가지고 있는 다음과 같은 다양한 모델을 로드할 수 있습니다.

  • VGG16
  • 인셉션V3
  • 레스넷
  • 모바일넷
  • 엑셉션
  • 인셉션ResNetV2

하지만 이 과정에서는 VGG16 네트워크 모델과 imageNet을 모델의 가중치로 사용합니다. 우리는 이미지를 사용하여 8가지 유형의 클래스를 분류하기 위해 네트워크를 미세 조정합니다. Kaggle 자연 이미지 데이터세트

VGG16 모델 archi강의

VGG16 모델 archi강의

AWS S3 버킷에 데이터 업로드

훈련 과정에서는 비행기, 자동차, 고양이, 개, 꽃, 과일, 오토바이, 사람 등 8가지 클래스의 자연 이미지 사진을 사용합니다. 먼저 데이터를 업로드해야 합니다. Amazon S3 버킷.

Amazon S3 버킷

단계 1) S3 계정에 로그인한 후 클러킹을 통해 버킷을 생성해보자 물통을 만들기

AWS S3 버킷에 데이터 업로드

단계 2) 이제 계정에 따라 버킷 이름과 지역을 선택하세요. 버킷 이름을 사용할 수 있는지 확인하세요. 그 후 클릭 만듭니다.

AWS S3 버킷에 데이터 업로드

단계 3) 보시다시피 버킷을 사용할 준비가 되었습니다. 하지만 보시다시피 액세스는 공개되지 않으므로 비공개로 유지하는 것이 좋습니다. 버킷 속성에서 이 버킷을 공개 액세스로 변경할 수 있습니다.

AWS S3 버킷에 데이터 업로드

단계 4) 이제 버킷에 훈련 데이터 업로드를 시작합니다. 여기서는 훈련 및 테스트 과정을 위한 사진으로 구성된 tar.gz 파일을 업로드하겠습니다.

AWS S3 버킷에 데이터 업로드

단계 5) 이제 파일을 클릭하고 복사하십시오. (링크) 다운로드할 수 있도록 말이죠.

AWS S3 버킷에 데이터 업로드

데이터 준비

Keras ImageData를 사용하여 훈련 데이터를 생성해야 합니다.Generator.

먼저 S3 버킷의 파일 링크와 함께 wget을 사용하여 다운로드해야 합니다.

!wget https://s3.us-east-2.amazonaws.com/naturalimages02/images.tar.gz		
!tar -xzf images.tar.gz

데이터를 다운로드한 후 학습 프로세스를 시작하겠습니다.

from keras.preprocessing.image import ImageDataGenerator
import numpy as np
import matplotlib.pyplot as plt

train_path = 'images/train/'
test_path = 'images/test/'
batch_size = 16
image_size = 224
num_class = 8


train_datagen = ImageDataGenerator(validation_split=0.3,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)

train_generator = train_datagen.flow_from_directory(
                        directory=train_path,
                        target_size=(image_size,image_size),
                        batch_size=batch_size,
                        class_mode='categorical',
                        color_mode='rgb',
                        shuffle=True)

이미지데이터Generator 디렉토리에서 X_training 데이터를 만듭니다. 해당 디렉터리의 하위 디렉터리는 각 개체의 클래스로 사용됩니다. 이미지는 RGB 색상 모드, Y_training 데이터에 대한 범주형 클래스 모드, 배치 크기 16으로 로드됩니다. 마지막으로 데이터를 섞습니다.

matplotlib로 이미지를 플로팅하여 무작위로 살펴보겠습니다.

x_batch, y_batch = train_generator.next()

fig=plt.figure()
columns = 4
rows = 4
for i in range(1, columns*rows):
    num = np.random.randint(batch_size)
    image = x_batch[num].astype(np.int)
    fig.add_subplot(rows, columns, i)
    plt.imshow(image)
plt.show()

데이터 준비

그런 다음 imageNet 사전 훈련된 가중치를 사용하여 VGG16에서 네트워크 모델을 만들어 보겠습니다. 계산 시간을 줄이기 위해 레이어를 훈련할 수 없도록 이러한 레이어를 동결하겠습니다.

VGG16에서 모델 만들기

import keras
from keras.models import Model, load_model
from keras.layers import Activation, Dropout, Flatten, Dense
from keras.preprocessing.image import ImageDataGenerator
from keras.applications.vgg16 import VGG16


#Load the VGG model
base_model = VGG16(weights='imagenet', include_top=False, input_shape=(image_size, image_size, 3))

print(base_model.summary())

    # Freeze the layers 
for layer in base_model.layers:
    layer.trainable = False
 
# # Create the model
model = keras.models.Sequential()

# # Add the vgg convolutional base model
model.add(base_model)
 
# # Add new layers
model.add(Flatten())
model.add(Dense(1024, activation='relu'))
model.add(Dense(1024, activation='relu'))
model.add(Dense(num_class, activation='softmax'))
 
# # Show a summary of the model. Check the number of trainable parameters    
print(model.summary())

아래에서 볼 수 있듯이 네트워크 모델이 요약되어 있습니다. VGG16 레이어의 입력에서 2개의 기능을 추출하는 1024개의 완전 연결 레이어와 소프트맥스 활성화를 통해 8개의 클래스를 계산하는 출력 레이어를 추가합니다.

Layer (type)                 Output Shape              Param #   
=================================================================
vgg16 (Model)                (None, 7, 7, 512)         14714688  
_________________________________________________________________
flatten_1 (Flatten)          (None, 25088)             0         
_________________________________________________________________
dense_1 (Dense)              (None, 1024)              25691136  
_________________________________________________________________
dense_2 (Dense)              (None, 1024)              1049600   
_________________________________________________________________
dense_3 (Dense)              (None, 8)                 8200      
=================================================================
Total params: 41,463,624
Trainable params: 26,748,936
Non-trainable params: 14,714,688

트레이닝

# # Compile the model
from keras.optimizers import SGD

model.compile(loss='categorical_crossentropy',
          optimizer=SGD(lr=1e-3),
          metrics=['accuracy'])

# # Start the training process
# model.fit(x_train, y_train, validation_split=0.30, batch_size=32, epochs=50, verbose=2)

# # #save the model
# model.save('catdog.h5')

history = model.fit_generator(
        train_generator,
        steps_per_epoch=train_generator.n/batch_size,
        epochs=10)
        
model.save('fine_tune.h5')

# summarize history for accuracy
import matplotlib.pyplot as plt

plt.plot(history.history['loss'])
plt.title('loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['loss'], loc='upper left')
plt.show()

결과

Epoch 1/10
432/431 [==============================] - 53s 123ms/step - loss: 0.5524 - acc: 0.9474 
Epoch 2/10
432/431 [==============================] - 52s 119ms/step - loss: 0.1571 - acc: 0.9831
Epoch 3/10
432/431 [==============================] - 51s 119ms/step - loss: 0.1087 - acc: 0.9871
Epoch 4/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0624 - acc: 0.9926
Epoch 5/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0591 - acc: 0.9938
Epoch 6/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0498 - acc: 0.9936
Epoch 7/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0403 - acc: 0.9958
Epoch 8/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0248 - acc: 0.9959
Epoch 9/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0466 - acc: 0.9942
Epoch 10/10
432/431 [==============================] - 52s 120ms/step - loss: 0.0338 - acc: 0.9947

트레이닝

보시다시피 손실이 크게 감소했으며 정확도는 거의 100%에 가깝습니다. 모델을 테스트하기 위해 인터넷에서 이미지를 무작위로 선택하고 다른 클래스의 테스트 폴더에 넣어 테스트했습니다.

모델 테스트

model = load_model('fine_tune.h5')

test_datagen = ImageDataGenerator()
train_generator = train_datagen.flow_from_directory(
                        directory=train_path,
                        target_size=(image_size,image_size),
                        batch_size=batch_size,
                        class_mode='categorical',
                        color_mode='rgb',
                        shuffle=True)

test_generator = test_datagen.flow_from_directory(
                        directory=test_path, 
                        target_size=(image_size, image_size),
                        color_mode='rgb',
                        shuffle=False,
                        class_mode='categorical',
                        batch_size=1)

filenames = test_generator.filenames
nb_samples = len(filenames)

fig=plt.figure()
columns = 4
rows = 4
for i in range(1, columns*rows -1):
    x_batch, y_batch = test_generator.next()

    name = model.predict(x_batch)
    name = np.argmax(name, axis=-1)
    true_name = y_batch
    true_name = np.argmax(true_name, axis=-1)

    label_map = (test_generator.class_indices)
    label_map = dict((v,k) for k,v in label_map.items()) #flip k,v
    predictions = [label_map[k] for k in name]
    true_value = [label_map[k] for k in true_name]

    image = x_batch[0].astype(np.int)
    fig.add_subplot(rows, columns, i)
    plt.title(str(predictions[0]) + ':' + str(true_value[0]))
    plt.imshow(image)
plt.show()

그리고 우리의 테스트는 아래와 같습니다! 1개의 이미지를 테스트한 결과 단 14개의 이미지만 잘못 예측되었습니다!

테스트 모델

Keras를 사용한 얼굴 인식 신경망

우리에게 인정이 필요한 이유

사람의 얼굴, 사물 유형, 얼굴에서 추정되는 사람의 나이, 심지어 그 사람의 얼굴 표정을 더 쉽게 인식하거나 식별할 수 있도록 하려면 인식이 필요합니다.

Keras를 사용한 얼굴 인식 신경망

어쩌면 사진에 친구의 얼굴을 표시하려고 할 때마다 Facebook의 기능이 대신 표시해 주므로, 먼저 표시할 필요 없이 친구의 얼굴을 표시한다는 것을 깨닫게 될 것입니다. 이것은 친구를 더 쉽게 태그할 수 있도록 Facebook에서 적용한 얼굴 인식입니다.

그럼 어떻게 작동하나요? 우리가 친구의 얼굴을 표시할 때마다 Facebook의 AI는 이를 학습하고 올바른 결과를 얻을 때까지 예측을 시도합니다. 우리 자신의 얼굴 인식을 만드는 데 사용할 것과 동일한 시스템입니다. 딥러닝을 활용해 나만의 얼굴인식을 만들어보자

네트워크 모델

VGG16 네트워크 모델을 사용하지만 VGGFace 가중치를 사용합니다.

VGG16 모델 archi강의

네트워크 모델

VGGFace란 무엇입니까? 이는 Parkhi, Omkar M. 등이 도입한 Keras의 Deep Face Recognition 구현입니다. “깊은 얼굴 인식.” BMVC(2015). 프레임워크는 VGG16을 네트워크로 사용합니다. archi강의.

VGGFace는 다음에서 다운로드할 수 있습니다. github

from keras.applications.vgg16 import VGG16
from keras_vggface.vggface import VGGFace

face_model = VGGFace(model='vgg16', 
                weights='vggface',
                input_shape=(224,224,3)) 
face_model.summary()

네트워크 요약을 보면 알 수 있듯이

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_1 (InputLayer)         (None, 224, 224, 3)       0         
_________________________________________________________________
conv1_1 (Conv2D)             (None, 224, 224, 64)      1792      
_________________________________________________________________
conv1_2 (Conv2D)             (None, 224, 224, 64)      36928     
_________________________________________________________________
pool1 (MaxPooling2D)         (None, 112, 112, 64)      0         
_________________________________________________________________
conv2_1 (Conv2D)             (None, 112, 112, 128)     73856     
_________________________________________________________________
conv2_2 (Conv2D)             (None, 112, 112, 128)     147584    
_________________________________________________________________
pool2 (MaxPooling2D)         (None, 56, 56, 128)       0         
_________________________________________________________________
conv3_1 (Conv2D)             (None, 56, 56, 256)       295168    
_________________________________________________________________
conv3_2 (Conv2D)             (None, 56, 56, 256)       590080    
_________________________________________________________________
conv3_3 (Conv2D)             (None, 56, 56, 256)       590080    
_________________________________________________________________
pool3 (MaxPooling2D)         (None, 28, 28, 256)       0         
_________________________________________________________________
conv4_1 (Conv2D)             (None, 28, 28, 512)       1180160   
_________________________________________________________________
conv4_2 (Conv2D)             (None, 28, 28, 512)       2359808   
_________________________________________________________________
conv4_3 (Conv2D)             (None, 28, 28, 512)       2359808   
_________________________________________________________________
pool4 (MaxPooling2D)         (None, 14, 14, 512)       0         
_________________________________________________________________
conv5_1 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
conv5_2 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
conv5_3 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
pool5 (MaxPooling2D)         (None, 7, 7, 512)         0         
_________________________________________________________________
flatten (Flatten)            (None, 25088)             0         
_________________________________________________________________
fc6 (Dense)                  (None, 4096)              102764544 
_________________________________________________________________
fc6/relu (Activation)        (None, 4096)              0         
_________________________________________________________________
fc7 (Dense)                  (None, 4096)              16781312  
_________________________________________________________________
fc7/relu (Activation)        (None, 4096)              0         
_________________________________________________________________
fc8 (Dense)                  (None, 2622)              10742334  
_________________________________________________________________
fc8/softmax (Activation)     (None, 2622)              0         
=================================================================
Total params: 145,002,878
Trainable params: 145,002,878
Non-trainable params: 0
_________________________________________________________________
Traceback (most recent call last):

우리는 할 것이다 전학 학습 + 작은 데이터 세트로 훈련을 더 빠르게 만드는 미세 조정. 먼저 기본 레이어를 동결하여 레이어를 학습할 수 없도록 합니다.

for layer in face_model.layers:
    layer.trainable = False

그런 다음 테스트 얼굴을 인식하기 위해 자체 레이어를 추가합니다. 우리는 2개의 완전 연결 레이어와 5명의 탐지를 위한 출력 레이어를 추가할 것입니다.

from keras.models import Model, Sequential
from keras.layers import Input, Convolution2D, ZeroPadding2D, MaxPooling2D, Flatten, Dense, Dropout, Activation

person_count = 5

last_layer = face_model.get_layer('pool5').output

x = Flatten(name='flatten')(last_layer)
x = Dense(1024, activation='relu', name='fc6')(x)
x = Dense(1024, activation='relu', name='fc7')(x)
out = Dense(person_count, activation='softmax', name='fc8')(x)

custom_face = Model(face_model.input, out)

네트워크 요약을 살펴보겠습니다.

Layer (type)                 Output Shape              Param #
=================================================================
input_1 (InputLayer)         (None, 224, 224, 3)       0
_________________________________________________________________
conv1_1 (Conv2D)             (None, 224, 224, 64)      1792
_________________________________________________________________
conv1_2 (Conv2D)             (None, 224, 224, 64)      36928
_________________________________________________________________
pool1 (MaxPooling2D)         (None, 112, 112, 64)      0
_________________________________________________________________
conv2_1 (Conv2D)             (None, 112, 112, 128)     73856
_________________________________________________________________
conv2_2 (Conv2D)             (None, 112, 112, 128)     147584
_________________________________________________________________
pool2 (MaxPooling2D)         (None, 56, 56, 128)       0
_________________________________________________________________
conv3_1 (Conv2D)             (None, 56, 56, 256)       295168
_________________________________________________________________
conv3_2 (Conv2D)             (None, 56, 56, 256)       590080
_________________________________________________________________
conv3_3 (Conv2D)             (None, 56, 56, 256)       590080
_________________________________________________________________
pool3 (MaxPooling2D)         (None, 28, 28, 256)       0
_________________________________________________________________
conv4_1 (Conv2D)             (None, 28, 28, 512)       1180160
_________________________________________________________________
conv4_2 (Conv2D)             (None, 28, 28, 512)       2359808
_________________________________________________________________
conv4_3 (Conv2D)             (None, 28, 28, 512)       2359808
_________________________________________________________________
pool4 (MaxPooling2D)         (None, 14, 14, 512)       0
_________________________________________________________________
conv5_1 (Conv2D)             (None, 14, 14, 512)       2359808
_________________________________________________________________
conv5_2 (Conv2D)             (None, 14, 14, 512)       2359808
_________________________________________________________________
conv5_3 (Conv2D)             (None, 14, 14, 512)       2359808
_________________________________________________________________
pool5 (MaxPooling2D)         (None, 7, 7, 512)         0
_________________________________________________________________
flatten (Flatten)            (None, 25088)             0
_________________________________________________________________
fc6 (Dense)                  (None, 1024)              25691136
_________________________________________________________________
fc7 (Dense)                  (None, 1024)              1049600
_________________________________________________________________
fc8 (Dense)                  (None, 5)                 5125
=================================================================
Total params: 41,460,549
Trainable params: 26,745,861
Non-trainable params: 14,714,688

위에서 볼 수 있듯이 pool5 레이어 이후에는 최종 인식을 위해 Dense 레이어에서 사용할 단일 특징 벡터로 평면화됩니다.

얼굴 준비하기

이제 얼굴을 준비합시다. 유명인 5명으로 구성된 디렉토리를 만들었습니다.

  • 잭 마
  • 제이슨 Statham
  • 조니 뎁
  • 로버트 다우니 주니어
  • 로완 앳킨슨

각 폴더에는 각 교육 및 평가 프로세스에 대한 10개의 그림이 포함되어 있습니다. 아주 적은 양의 데이터지만 그게 어려운 일이겠죠?

Keras 도구의 도움을 받아 데이터를 준비하겠습니다. 이 함수는 데이터 세트 폴더에서 반복한 다음 훈련에 사용할 수 있도록 준비합니다.

from keras.preprocessing.image import ImageDataGenerator
batch_size = 5
train_path = 'data/'
eval_path = 'eval/'

train_datagen = ImageDataGenerator(rescale=1./255,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)

valid_datagen = ImageDataGenerator(rescale=1./255,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)

train_generator = train_datagen.flow_from_directory(
                        train_path,
                        target_size=(image_size,image_size),
                        batch_size=batch_size,
                        class_mode='sparse',
                        color_mode='rgb')

valid_generator = valid_datagen.flow_from_directory(
    directory=eval_path,
    target_size=(224, 224),
    color_mode='rgb',
    batch_size=batch_size,
    class_mode='sparse',
    shuffle=True,
)

모델 훈련

손실 함수와 옵티마이저를 사용하여 네트워크를 컴파일하여 훈련 프로세스를 시작하겠습니다. 여기서는 학습 최적화 프로그램인 SGD의 도움을 받아 sparse_categorical_crossentropy를 손실 함수로 사용합니다.

from keras.optimizers import SGD

custom_face.compile(loss='sparse_categorical_crossentropy',
                         optimizer=SGD(lr=1e-4, momentum=0.9),
                         metrics=['accuracy'])

history = custom_face.fit_generator(
        train_generator,
        validation_data=valid_generator,
        steps_per_epoch=49/batch_size,
        validation_steps=valid_generator.n,
        epochs=50)

custom_face.evaluate_generator(generator=valid_generator)
        
custom_face.save('vgg_face.h5')
Epoch 25/50
10/9 [==============================] - 60s 6s/step - loss: 1.4882 - acc: 0.8998 - val_loss: 1.5659 - val_acc: 0.5851
Epoch 26/50
10/9 [==============================] - 59s 6s/step - loss: 1.4882 - acc: 0.8998 - val_loss: 1.5638 - val_acc: 0.5809
Epoch 27/50
10/9 [==============================] - 60s 6s/step - loss: 1.4779 - acc: 0.8597 - val_loss: 1.5613 - val_acc: 0.5477
Epoch 28/50
10/9 [==============================] - 60s 6s/step - loss: 1.4755 - acc: 0.9199 - val_loss: 1.5576 - val_acc: 0.5809
Epoch 29/50
10/9 [==============================] - 60s 6s/step - loss: 1.4794 - acc: 0.9153 - val_loss: 1.5531 - val_acc: 0.5892
Epoch 30/50
10/9 [==============================] - 60s 6s/step - loss: 1.4714 - acc: 0.8953 - val_loss: 1.5510 - val_acc: 0.6017
Epoch 31/50
10/9 [==============================] - 60s 6s/step - loss: 1.4552 - acc: 0.9199 - val_loss: 1.5509 - val_acc: 0.5809
Epoch 32/50
10/9 [==============================] - 60s 6s/step - loss: 1.4504 - acc: 0.9199 - val_loss: 1.5492 - val_acc: 0.5975
Epoch 33/50
10/9 [==============================] - 60s 6s/step - loss: 1.4497 - acc: 0.8998 - val_loss: 1.5490 - val_acc: 0.5851
Epoch 34/50
10/9 [==============================] - 60s 6s/step - loss: 1.4453 - acc: 0.9399 - val_loss: 1.5529 - val_acc: 0.5643
Epoch 35/50
10/9 [==============================] - 60s 6s/step - loss: 1.4399 - acc: 0.9599 - val_loss: 1.5451 - val_acc: 0.5768
Epoch 36/50
10/9 [==============================] - 60s 6s/step - loss: 1.4373 - acc: 0.8998 - val_loss: 1.5424 - val_acc: 0.5768
Epoch 37/50
10/9 [==============================] - 60s 6s/step - loss: 1.4231 - acc: 0.9199 - val_loss: 1.5389 - val_acc: 0.6183
Epoch 38/50
10/9 [==============================] - 59s 6s/step - loss: 1.4247 - acc: 0.9199 - val_loss: 1.5372 - val_acc: 0.5934
Epoch 39/50
10/9 [==============================] - 60s 6s/step - loss: 1.4153 - acc: 0.9399 - val_loss: 1.5406 - val_acc: 0.5560
Epoch 40/50
10/9 [==============================] - 60s 6s/step - loss: 1.4074 - acc: 0.9800 - val_loss: 1.5327 - val_acc: 0.6224
Epoch 41/50
10/9 [==============================] - 60s 6s/step - loss: 1.4023 - acc: 0.9800 - val_loss: 1.5305 - val_acc: 0.6100
Epoch 42/50
10/9 [==============================] - 59s 6s/step - loss: 1.3938 - acc: 0.9800 - val_loss: 1.5269 - val_acc: 0.5975
Epoch 43/50
10/9 [==============================] - 60s 6s/step - loss: 1.3897 - acc: 0.9599 - val_loss: 1.5234 - val_acc: 0.6432
Epoch 44/50
10/9 [==============================] - 60s 6s/step - loss: 1.3828 - acc: 0.9800 - val_loss: 1.5210 - val_acc: 0.6556
Epoch 45/50
10/9 [==============================] - 59s 6s/step - loss: 1.3848 - acc: 0.9599 - val_loss: 1.5234 - val_acc: 0.5975
Epoch 46/50
10/9 [==============================] - 60s 6s/step - loss: 1.3716 - acc: 0.9800 - val_loss: 1.5216 - val_acc: 0.6432
Epoch 47/50
10/9 [==============================] - 60s 6s/step - loss: 1.3721 - acc: 0.9800 - val_loss: 1.5195 - val_acc: 0.6266
Epoch 48/50
10/9 [==============================] - 60s 6s/step - loss: 1.3622 - acc: 0.9599 - val_loss: 1.5108 - val_acc: 0.6141
Epoch 49/50
10/9 [==============================] - 60s 6s/step - loss: 1.3452 - acc: 0.9399 - val_loss: 1.5140 - val_acc: 0.6432
Epoch 50/50
10/9 [==============================] - 60s 6s/step - loss: 1.3387 - acc: 0.9599 - val_loss: 1.5100 - val_acc: 0.6266

보시다시피 검증 정확도는 최대 64%입니다. 이는 소량의 훈련 데이터에 대해 좋은 결과입니다. 모델이 얼굴에 대해 더 많이 학습하고 더 높은 정확도를 달성할 수 있도록 더 많은 레이어를 추가하거나 더 많은 훈련 이미지를 추가하여 이를 개선할 수 있습니다.

테스트 사진으로 모델을 테스트해 보겠습니다.

테스트 사진

from keras.models import load_model
from keras.preprocessing.image import load_img, save_img, img_to_array
from keras_vggface.utils import preprocess_input

test_img = image.load_img('test.jpg', target_size=(224, 224))
img_test = image.img_to_array(test_img)
img_test = np.expand_dims(img_test, axis=0)
img_test = utils.preprocess_input(img_test)
predictions = model.predict(img_test)
predicted_class=np.argmax(predictions,axis=1)

labels = (train_generator.class_indices)
labels = dict((v,k) for k,v in labels.items())
predictions = [labels[k] for k in predicted_class]
print(predictions)
['RobertDJr']

로버트 다우니 주니어의 사진을 테스트 사진으로 사용하여 예측한 얼굴이 사실임을 보여줍니다!

라이브캠을 활용한 예측!

웹캠의 입력을 사용하여 구현 기술을 테스트해 보면 어떨까요? Haar Face 캐스케이드와 함께 OpenCV를 사용하여 얼굴을 찾고 네트워크 모델의 도움으로 사람을 인식할 수 있습니다.

첫 번째 단계는 당신과 당신의 친구의 얼굴을 준비하는 것입니다. 데이터가 많을수록 결과가 더 좋아집니다!

이전 단계와 같이 네트워크를 준비하고 훈련합니다. 훈련이 완료된 후 이 줄을 추가하여 캠에서 입력 이미지를 가져옵니다.

#Load trained model
from keras.models import load_model
from keras_vggface import utils
import cv2

image_size = 224
device_id = 0 #camera_device id 

model = load_model('my faces.h5')

#make labels according to your dataset folder 
labels = dict(fisrtname=0,secondname=1) #and so on
print(labels)

cascade_classifier = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
camera = cv2.VideoCapture(device_id)

while camera.isOpened():
    ok, cam_frame = camera.read()
    if not ok:
        break
    
    gray_img=cv2.cvtColor(cam_frame, cv2.COLOR_BGR2GRAY)
    faces= cascade_classifier.detectMultiScale(gray_img, minNeighbors=5)

    for (x,y,w,h) in faces:
        cv2.rectangle(cam_frame,(x,y),(x+w,y+h),(255,255,0),2)
        roi_color = cam_frame [y:y+h, x:x+w]
        roi color = cv2.cvtColor(roi_color, cv2.COLOR_BGR2RGB)
        roi_color = cv2.resize(roi_color, (image_size, image_size))
        image = roi_color.astype(np.float32, copy=False)
        image = np.expand_dims(image, axis=0)
        image = preprocess_input(image, version=1) # or version=2
        preds = model.predict(image)
        predicted_class=np.argmax(preds,axis=1)

        labels = dict((v,k) for k,v in labels.items())
        name = [labels[k] for k in predicted_class]

        cv2.putText(cam_frame,str(name), 
                    (x + 10, y + 10), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,0,255), 2)
        
    cv2.imshow('video image', cam_frame)
    key = cv2.waitKey(30)
    if key == 27: # press 'ESC' to quit
        break

camera.release()
cv2.destroyAllWindows()

어느 것이 더 낫습니까? 케라스 또는 텐서플로우

Keras는 스크립트 작성 시 단순성을 제공합니다. 이해하기 어렵지 않기 때문에 Keras를 사용하면 직접 작성하고 이해할 수 있습니다. 더 사용자 친화적이고 구현하기 쉬우며 모델을 실행하기 위해 많은 변수를 만들 필요가 없습니다. 따라서 백엔드 프로세스의 모든 세부 사항을 이해할 필요는 없습니다.

반면에 Tensorflow는 임의의 계산 그래프나 모델을 만들려는 경우 유연성과 고급 작업을 제공하는 하위 수준 작업입니다. Tensorflow는 또한 다음의 도움으로 프로세스를 시각화할 수 있습니다. 텐서 보드 그리고 특수 디버거 도구입니다.

따라서 그다지 많지 않은 com으로 딥러닝 작업을 시작하고 싶다면plex그렇다면 Keras를 사용하세요. Keras는 Tensorflow보다 사용하기 쉽고 사용자 친화적이며 구현하기 쉽기 때문입니다. 하지만 딥러닝 프로젝트나 연구에서 자신만의 알고리즘을 작성하려면 대신 Tensorflow를 사용해야 합니다.

요약

이제 이 튜토리얼에서 논의하고 수행한 모든 내용을 요약해 보겠습니다.

  • 백엔드 엔진의 도움으로 딥 러닝 네트워크를 더 쉽게 만드는 데 사용되는 고급 API의 Keras입니다.
  • Keras는 Python 지원으로 사용하고 이해하기 쉽기 때문에 그 어느 때보다 자연스러운 느낌을 줍니다. 딥러닝을 배우고 싶은 초보자나 API를 쉽게 사용하고 싶은 연구자에게 좋습니다.
  • 설치 과정은 쉽고 가상 환경이나 다음과 같은 외부 플랫폼을 사용할 수 있습니다. AWS.
  • Keras에는 다양한 종류의 네트워크 모델도 함께 제공되므로 자체 네트워크 모델을 사전 훈련하고 미세 조정하는 데 사용 가능한 모델을 더 쉽게 사용할 수 있습니다.
  • 또한 딥 러닝 목적으로 전 세계 커뮤니티 코드에서 Keras를 사용하는 방법에 대한 많은 튜토리얼과 기사가 있습니다.