Caffe2-퀵 가이드

지난 몇 년 동안 딥 러닝은 머신 러닝에서 큰 트렌드가되었습니다. 이전에 해결할 수 없었던 문제를 해결하기 위해 성공적으로 적용되었습니다. Vision, Speech Recognition and Natural Language Processing(NLP). 딥 러닝이 적용되고 그 유용성을 보여주는 더 많은 영역이 있습니다.

Caffe (Convolutional Architecture for Fast Feature Embedding) 에서 개발 된 딥 러닝 프레임 워크입니다. Berkeley Vision and Learning Center (BVLC). Caffe 프로젝트는 Yangqing Jia가 Ph.D. 캘리포니아 대학교 버클리에서. Caffe는 딥 러닝을 쉽게 실험 할 수있는 방법을 제공합니다. C ++로 작성되었으며 다음에 대한 바인딩을 제공합니다.Python 과 Matlab.

다음과 같은 다양한 유형의 딥 러닝 아키텍처를 지원합니다. CNN (컨볼 루션 신경망), LSTM(장단기 메모리) 및 FC (완전 연결됨). GPU를 지원하므로 심층 신경망과 관련된 프로덕션 환경에 이상적입니다. 또한 다음과 같은 CPU 기반 커널 라이브러리를 지원합니다.NVIDIA, CUDA 심층 신경망 라이브러리 (cuDNN) 및 인텔 수학 커널 라이브러리 (Intel MKL).

2017 년 4 월 미국 기반 소셜 네트워킹 서비스 회사 인 Facebook은 현재 RNN (Recurrent Neural Networks)이 포함 된 Caffe2를 발표했으며 2018 년 3 월 Caffe2는 PyTorch로 합병되었습니다. Caffe2 제작자와 커뮤니티 구성원은 다양한 문제를 해결하기위한 모델을 만들었습니다. 이러한 모델은 사전 학습 된 모델로 대중에게 제공됩니다. Caffe2는 제작자가 이러한 모델을 사용하고 데이터 세트에 대한 예측을위한 자체 네트워크를 만드는 데 도움을줍니다.

Caffe2에 대해 자세히 알아보기 전에 machine learning 과 deep learning. 이것은 Caffe2에서 모델을 만들고 사용하는 방법을 이해하는 데 필요합니다.

기계 학습 대 딥 러닝

기계 학습 알고리즘 (기존 알고리즘이든 딥 러닝 알고리즘이든)에서 데이터 세트의 특징 선택은 원하는 예측 정확도를 얻는 데 매우 중요한 역할을합니다. 전통적인 기계 학습 기술에서feature selection대부분 인간의 검사, 판단 및 깊은 영역 지식에 의해 수행됩니다. 때로는 기능 선택을 위해 몇 가지 테스트 된 알고리즘의 도움을 구할 수 있습니다.

전통적인 기계 학습 흐름은 아래 그림에 설명되어 있습니다.

딥 러닝에서 특징 선택은 자동이며 딥 러닝 알고리즘 자체의 일부입니다. 이것은 아래 그림에 나와 있습니다.

딥 러닝 알고리즘에서 feature engineering자동으로 수행됩니다. 일반적으로 기능 엔지니어링은 시간이 많이 걸리며 도메인에 대한 전문 지식이 필요합니다. 자동 특징 추출을 구현하기 위해 딥 러닝 알고리즘은 일반적으로 엄청난 양의 데이터를 요구하므로 수천 및 수만 개의 데이터 포인트 만있는 경우 딥 러닝 기술은 만족스러운 결과를 제공하지 못할 수 있습니다.

더 큰 데이터를 사용하면 딥 러닝 알고리즘이 기존 ML 알고리즘에 비해 더 나은 결과를 생성하며 기능 엔지니어링이 적거나 아예 없다는 장점이 추가됩니다.

이제 딥 러닝에 대한 통찰력을 얻었으므로 Caffe에 대한 개요를 살펴 보겠습니다.

CNN 훈련

이미지 분류를 위해 CNN을 훈련하는 과정을 알아 보겠습니다. 프로세스는 다음 단계로 구성됩니다.

• Data Preparation−이 단계에서는 이미지를 중앙에서 자르고 크기를 조정하여 훈련 및 테스트를위한 모든 이미지가 동일한 크기가되도록합니다. 이것은 일반적으로 이미지 데이터에서 작은 Python 스크립트를 실행하여 수행됩니다.

• Model Definition−이 단계에서는 CNN 아키텍처를 정의합니다. 구성은.pb (protobuf)파일. 일반적인 CNN 아키텍처는 아래 그림에 나와 있습니다.

• Solver Definition− 솔버 구성 파일을 정의합니다. Solver는 모델 최적화를 수행합니다.

• Model Training− 내장 된 Caffe 유틸리티를 사용하여 모델을 훈련합니다. 교육에는 상당한 시간과 CPU 사용량이 소요될 수 있습니다. 훈련이 완료된 후 Caffe는 모델을 파일에 저장하고 나중에 테스트 데이터 및 예측을위한 최종 배포에 사용할 수 있습니다.

Caffe2의 새로운 기능

Caffe2에서는 바로 사용할 수있는 사전 훈련 된 많은 모델을 찾을 수 있으며 새로운 모델 및 알고리즘의 커뮤니티 기여를 매우 자주 활용합니다. 생성 한 모델은 클라우드에서 GPU 성능을 사용하여 쉽게 확장 할 수 있으며 크로스 플랫폼 라이브러리를 통해 모바일에서 대량 사용으로 줄일 수도 있습니다.

Caffe보다 Caffe2에서 개선 된 사항은 다음과 같이 요약 할 수 있습니다.

• 모바일 배포
• 새로운 하드웨어 지원
• 대규모 분산 교육 지원
• 양자화 된 계산
• Facebook에서 스트레스 테스트

사전 훈련 된 모델 데모

Berkeley Vision and Learning Center (BVLC) 사이트는 사전 훈련 된 네트워크의 데모를 제공합니다. 이미지 분류를위한 이러한 네트워크 중 하나는 여기에 명시된 링크에서 사용할 수 있습니다.https://caffe2.ai/docs/learn-more#null__caffe-neural-network-for-image-classification 아래 스크린 샷에 묘사되어 있습니다.

스크린 샷에서 개의 이미지는 예측 정확도로 분류되고 레이블이 지정됩니다. 그것은 또한 단지0.068 seconds이미지를 분류합니다. 이미지 URL을 지정하거나 화면 하단에 제공되는 옵션에서 이미지 자체를 업로드하여 원하는 이미지를 시도 할 수 있습니다.

이제 Caffe2의 기능에 대한 충분한 통찰력을 얻었으므로 Caffe2를 직접 실험 할 때입니다. 사전 학습 된 모델을 사용하거나 자체 Python 코드로 모델을 개발하려면 먼저 컴퓨터에 Caffe2를 설치해야합니다.

링크에서 사용할 수있는 Caffe2 사이트의 설치 페이지에서 https://caffe2.ai/docs/getting-started.html 플랫폼 및 설치 유형을 선택하려면 다음이 표시됩니다.

위의 스크린 샷에서 볼 수 있듯이 Caffe2 모바일 플랫폼을 포함한 여러 인기 플랫폼을 지원합니다.

이제 단계를 이해하겠습니다. MacOS installation 이 튜토리얼의 모든 프로젝트가 테스트됩니다.

MacOS 설치

설치는 아래와 같이 4 가지 유형이 있습니다.

• 사전 빌드 된 바이너리
• 소스에서 빌드
• Docker 이미지
• Cloud

기본 설정에 따라 설치 유형으로 위 중 하나를 선택하십시오. 여기에 제공된 지침은 Caffe2 설치 사이트에 따라pre-built binaries. Anaconda를 사용하여Jupyter environment. 콘솔 프롬프트에서 다음 명령을 실행하십시오.

pip install torch_nightly -f 
https://download.pytorch.org/whl/nightly/cpu/torch_nightly.html

위의 것 외에도 다음 명령을 사용하여 설치되는 몇 가지 타사 라이브러리가 필요합니다.

conda install -c anaconda setuptools
conda install -c conda-forge graphviz  
conda install -c conda-forge hypothesis
conda install -c conda-forge ipython
conda install -c conda-forge jupyter
conda install -c conda-forge matplotlib
conda install -c anaconda notebook
conda install -c anaconda pydot
conda install -c conda-forge python-nvd3
conda install -c anaconda pyyaml
conda install -c anaconda requests
conda install -c anaconda scikit-image
conda install -c anaconda scipy

Caffe2 웹 사이트의 일부 튜토리얼은 다음을 설치해야합니다. zeromq, 다음 명령을 사용하여 설치-

conda install -c anaconda zeromq

Windows / Linux 설치

콘솔 프롬프트에서 다음 명령을 실행하십시오-

conda install -c pytorch pytorch-nightly-cpu

눈치 채 셨겠지만 위의 설치를 사용하려면 Anaconda가 필요합니다. 에 지정된대로 추가 패키지를 설치해야합니다.MacOS installation.

설치 테스트

설치를 테스트하기 위해 Juypter 프로젝트에서 잘라내어 붙여넣고 실행할 수있는 작은 Python 스크립트가 아래에 제공됩니다.

from caffe2.python import workspace
import numpy as np
print ("Creating random data")
data = np.random.rand(3, 2)
print(data)
print ("Adding data to workspace ...")
workspace.FeedBlob("mydata", data)
print ("Retrieving data from workspace")
mydata = workspace.FetchBlob("mydata")
print(mydata)

위의 코드를 실행하면 다음 출력이 표시됩니다.

Creating random data
[[0.06152718 0.86448082]
[0.36409966 0.52786113]
[0.65780886 0.67101053]]
Adding data to workspace ...
Retrieving data from workspace
[[0.06152718 0.86448082]
[0.36409966 0.52786113]
[0.65780886 0.67101053]]

빠른 참조를 위해 설치 테스트 페이지의 스크린 샷이 여기에 표시됩니다.

이제 컴퓨터에 Caffe2를 설치 했으므로 자습서 응용 프로그램을 설치하십시오.

튜토리얼 설치

콘솔에서 다음 명령을 사용하여 튜토리얼 소스를 다운로드하십시오.

git clone --recursive https://github.com/caffe2/tutorials caffe2_tutorials

다운로드가 완료되면 다음에서 여러 Python 프로젝트를 찾을 수 있습니다. caffe2_tutorials설치 디렉토리의 폴더. 이 폴더의 스크린 샷은 빠른 열람을 위해 제공됩니다.

/Users/yourusername/caffe2_tutorials

이 튜토리얼 중 일부를 열어서 Caffe2 code처럼 보입니다. 이 자습서에서 설명하는 다음 두 프로젝트는 대부분 위에 표시된 샘플을 기반으로합니다.

이제 우리 자신의 파이썬 코딩을 할 시간입니다. Caffe2에서 사전 훈련 된 모델을 사용하는 방법을 이해하겠습니다. 나중에 자신의 데이터 세트에 대한 훈련을 위해 사소한 신경망을 만드는 방법을 배웁니다.

Python 애플리케이션에서 사전 학습 된 모델을 사용하는 방법을 배우기 전에 먼저 모델이 머신에 설치되어 있고 Python 코드를 통해 액세스 할 수 있는지 확인하십시오.

Caffe2를 설치하면 사전 학습 된 모델이 설치 폴더에 복사됩니다. Anaconda가 설치된 컴퓨터에서 이러한 모델은 다음 폴더에서 사용할 수 있습니다.

anaconda3/lib/python3.7/site-packages/caffe2/python/models

이러한 모델이 있는지 컴퓨터의 설치 폴더를 확인하십시오. 다음과 같은 짧은 Python 스크립트를 사용하여 설치 폴더에서 이러한 모델을로드 할 수 있습니다.

CAFFE_MODELS = os.path.expanduser("/anaconda3/lib/python3.7/site-packages/caffe2/python/models")
INIT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'init_net.pb')
PREDICT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'predict_net.pb')
print(INIT_NET)
print(PREDICT_NET)

스크립트가 성공적으로 실행되면 다음 출력이 표시됩니다.

/anaconda3/lib/python3.7/site-packages/caffe2/python/models/squeezenet/init_net.pb
/anaconda3/lib/python3.7/site-packages/caffe2/python/models/squeezenet/predict_net.pb

이것은 squeezenet 모듈이 컴퓨터에 설치되고 코드에 액세스 할 수 있습니다.

이제 Caffe2를 사용하여 이미지 분류를위한 Python 코드를 작성할 준비가되었습니다. squeezenet 사전 훈련 된 모듈.

이 단원에서는 사전 훈련 된 모델을 사용하여 주어진 이미지에서 객체를 감지하는 방법을 배웁니다. 당신은 사용할 것입니다squeezenet 주어진 이미지에서 물체를 매우 정확하게 감지하고 분류하는 사전 훈련 된 모듈입니다.

새로 열기 Juypter notebook 이 이미지 분류 응용 프로그램을 개발하는 단계를 따릅니다.

라이브러리 가져 오기

먼저 아래 코드를 사용하여 필요한 패키지를 가져옵니다.

from caffe2.proto import caffe2_pb2
from caffe2.python import core, workspace, models
import numpy as np
import skimage.io
import skimage.transform
from matplotlib import pyplot
import os
import urllib.request as urllib2
import operator

다음으로 몇 가지 설정 variables −

INPUT_IMAGE_SIZE = 227
mean = 128

훈련에 사용되는 이미지는 분명히 다양한 크기입니다. 이러한 모든 이미지는 정확한 훈련을 위해 고정 된 크기로 변환되어야합니다. 마찬가지로 프로덕션 환경에서 예측하려는 테스트 이미지와 이미지도 훈련 중에 사용한 것과 동일한 크기로 변환해야합니다. 따라서 위의 변수를 만듭니다.INPUT_IMAGE_SIZE 가치가있는 227. 따라서 모든 이미지를 크기로 변환합니다.227x227 분류기에서 사용하기 전에

또한 다음과 같은 변수를 선언합니다. mean 가치가있는 128, 나중에 분류 결과를 개선하는 데 사용됩니다.

다음으로 이미지 처리를위한 두 가지 기능을 개발합니다.

이미지 처리

이미지 처리는 두 단계로 구성됩니다. 첫 번째는 이미지 크기를 조정하는 것이고 두 번째는 이미지를 중앙에서 자르는 것입니다. 이 두 단계에서는 크기 조정 및 자르기를위한 두 가지 함수를 작성합니다.

이미지 크기 조정

먼저 이미지 크기를 조정하는 함수를 작성합니다. 앞서 말했듯이 이미지 크기를227x227. 그래서 우리가 함수를 정의합시다resize 다음과 같이-

def resize(img, input_height, input_width):

너비를 높이로 나누어 이미지의 종횡비를 얻습니다.

original_aspect = img.shape[1]/float(img.shape[0])

종횡비가 1보다 크면 이미지가 넓다는 것을 나타냅니다. 즉, 가로 모드임을 나타냅니다. 이제 이미지 높이를 조정하고 다음 코드를 사용하여 크기가 조정 된 이미지를 반환합니다.

if(original_aspect>1):
   new_height = int(original_aspect * input_height)
   return skimage.transform.resize(img, (input_width,
   new_height), mode='constant', anti_aliasing=True, anti_aliasing_sigma=None)

가로 세로 비율이 less than 1, 그것은 나타냅니다 portrait mode. 이제 다음 코드를 사용하여 너비를 조정합니다.

if(original_aspect<1):
   new_width = int(input_width/original_aspect)
   return skimage.transform.resize(img, (new_width,
   input_height), mode='constant', anti_aliasing=True, anti_aliasing_sigma=None)

종횡비가 같으면 1, 높이 / 너비 조정은하지 않습니다.

if(original_aspect == 1):
   return skimage.transform.resize(img, (input_width,
   input_height), mode='constant', anti_aliasing=True, anti_aliasing_sigma=None)

빠른 참조를 위해 전체 기능 코드가 아래에 나와 있습니다.

def resize(img, input_height, input_width):
   original_aspect = img.shape[1]/float(img.shape[0])
   if(original_aspect>1):
      new_height = int(original_aspect * input_height)
      return skimage.transform.resize(img, (input_width,
	   new_height), mode='constant', anti_aliasing=True, anti_aliasing_sigma=None)
   if(original_aspect<1):
         new_width = int(input_width/original_aspect)
         return skimage.transform.resize(img, (new_width,
         input_height), mode='constant', anti_aliasing=True, anti_aliasing_sigma=None)
   if(original_aspect == 1):
         return skimage.transform.resize(img, (input_width,
         input_height), mode='constant', anti_aliasing=True, anti_aliasing_sigma=None)

이제 이미지의 중앙을 자르는 함수를 작성합니다.

이미지 자르기

우리는 crop_image 다음과 같이 기능-

def crop_image(img,cropx,cropy):

다음 문을 사용하여 이미지의 크기를 추출합니다.

y,x,c = img.shape

다음 두 줄의 코드를 사용하여 이미지의 새로운 시작점을 만듭니다.

startx = x//2-(cropx//2)
starty = y//2-(cropy//2)

마지막으로 새로운 차원의 이미지 객체를 생성하여 잘린 이미지를 반환합니다.

return img[starty:starty+cropy,startx:startx+cropx]

빠른 참조를 위해 전체 기능 코드가 아래에 나와 있습니다.

def crop_image(img,cropx,cropy):
   y,x,c = img.shape
   startx = x//2-(cropx//2)
   starty = y//2-(cropy//2)
   return img[starty:starty+cropy,startx:startx+cropx]

이제 이러한 함수를 테스트하는 코드를 작성합니다.

처리 이미지

먼저 이미지 파일을 images 프로젝트 디렉토리 내의 하위 폴더. tree.jpg파일이 프로젝트에 복사됩니다. 다음 Python 코드는 이미지를로드하고 콘솔에 표시합니다.

img = skimage.img_as_float(skimage.io.imread("images/tree.jpg")).astype(np.float32)
print("Original Image Shape: " , img.shape)
pyplot.figure()
pyplot.imshow(img)
pyplot.title('Original image')

출력은 다음과 같습니다.

원본 이미지의 크기는 600 x 960. 사양에 맞게 크기를 조정해야합니다.227 x 227. 이전에 정의 된resize함수가이 일을합니다.

img = resize(img, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE)
print("Image Shape after resizing: " , img.shape)
pyplot.figure()
pyplot.imshow(img)
pyplot.title('Resized image')

출력은 다음과 같습니다.

이제 이미지 크기는 227 x 363. 우리는 이것을자를 필요가 있습니다.227 x 227알고리즘에 대한 최종 피드입니다. 이를 위해 이전에 정의 된 자르기 함수를 호출합니다.

img = crop_image(img, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE)
print("Image Shape after cropping: " , img.shape)
pyplot.figure()
pyplot.imshow(img)
pyplot.title('Center Cropped')

아래는 코드의 출력입니다.

이 시점에서 이미지의 크기는 227 x 227추가 처리 준비가되었습니다. 이제 이미지 축을 교체하여 세 가지 색상을 세 가지 다른 영역으로 추출합니다.

img = img.swapaxes(1, 2).swapaxes(0, 1)
print("CHW Image Shape: " , img.shape)

다음은 출력입니다.

CHW Image Shape: (3, 227, 227)

이제 마지막 축이 배열의 첫 번째 차원이되었습니다. 이제 다음 코드를 사용하여 세 채널을 플로팅합니다.

pyplot.figure()
for i in range(3):
   pyplot.subplot(1, 3, i+1)
   pyplot.imshow(img[i])
   pyplot.axis('off')
   pyplot.title('RGB channel %d' % (i+1))

출력은 다음과 같습니다.

마지막으로 이미지에 대해 변환과 같은 추가 처리를 수행합니다. Red Green Blue ...에 Blue Green Red (RGB to BGR), 더 나은 결과를 위해 평균을 제거하고 다음 세 줄의 코드를 사용하여 배치 크기 축을 추가합니다.

# convert RGB --> BGR
img = img[(2, 1, 0), :, :]
# remove mean
img = img * 255 - mean
# add batch size axis
img = img[np.newaxis, :, :, :].astype(np.float32)

이 시점에서 이미지는 NCHW format우리 네트워크에 공급할 준비가되었습니다. 다음으로 사전 학습 된 모델 파일을로드하고 예측을 위해 위의 이미지를 여기에 제공합니다.

처리 된 이미지의 개체 예측

먼저 경로를 설정합니다. init 과 predict 사전 훈련 된 Caffe 모델에 정의 된 네트워크.

모델 파일 경로 설정

이전 논의에서 기억하십시오. 모든 사전 훈련 된 모델은 models폴더. 이 폴더의 경로를 다음과 같이 설정합니다.

CAFFE_MODELS = os.path.expanduser("/anaconda3/lib/python3.7/site-packages/caffe2/python/models")

우리는 경로를 설정 init_net protobuf 파일 squeezenet 다음과 같이 모델-

INIT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'init_net.pb')

마찬가지로, 우리는 경로를 설정 predict_net 다음과 같이 protobuf-

PREDICT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'predict_net.pb')

진단 목적으로 두 경로를 인쇄합니다.

print(INIT_NET)
print(PREDICT_NET)

출력과 함께 위의 코드는 빠른 참조를 위해 여기에 제공됩니다.

CAFFE_MODELS = os.path.expanduser("/anaconda3/lib/python3.7/site-packages/caffe2/python/models")
INIT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'init_net.pb')
PREDICT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'predict_net.pb')
print(INIT_NET)
print(PREDICT_NET)

출력은 아래에 언급되어 있습니다.

/anaconda3/lib/python3.7/site-packages/caffe2/python/models/squeezenet/init_net.pb
/anaconda3/lib/python3.7/site-packages/caffe2/python/models/squeezenet/predict_net.pb

다음으로 예측자를 생성합니다.

예측 자 생성

다음 두 문장을 사용하여 모델 파일을 읽었습니다.

with open(INIT_NET, "rb") as f:
   init_net = f.read()
with open(PREDICT_NET, "rb") as f:
   predict_net = f.read()

예측자는 두 파일에 대한 포인터를 매개 변수로 전달하여 생성됩니다. Predictor 함수.

p = workspace.Predictor(init_net, predict_net)

그만큼 pobject는 주어진 이미지에서 개체를 예측하는 데 사용되는 예측 변수입니다. 각 입력 이미지는 이전에 수행 한 것과 같이 NCHW 형식이어야합니다.tree.jpg 파일.

개체 예측

주어진 이미지에서 물체를 예측하는 것은 간단합니다. 명령 한 줄만 실행하면됩니다. 우리는 부른다run 에 방법 predictor 주어진 이미지에서 물체 감지를위한 물체.

results = p.run({'data': img})

이제 예측 결과를 results 가독성을 위해 배열로 변환합니다.

results = np.asarray(results)

다음 문장을 사용하여 이해를 돕기 위해 배열의 차원을 인쇄하십시오-

print("results shape: ", results.shape)

출력은 다음과 같습니다.

results shape: (1, 1, 1000, 1, 1)

이제 불필요한 축을 제거합니다.

preds = np.squeeze(results)

이제 최상위 예측은 max 가치 preds 정렬.

curr_pred, curr_conf = max(enumerate(preds), key=operator.itemgetter(1))
print("Prediction: ", curr_pred)
print("Confidence: ", curr_conf)

출력은 다음과 같습니다.

Prediction: 984
Confidence: 0.89235985

보시다시피 모델은 인덱스 값이있는 개체를 예측했습니다. 984 와 89%자신. 984의 색인은 어떤 종류의 물체가 감지되는지 이해하는 데별로 의미가 없습니다. 인덱스 값을 사용하여 객체의 문자열 이름을 가져와야합니다. 모델이 인식하는 객체의 종류는 해당 인덱스 값과 함께 github 저장소에서 사용할 수 있습니다.

이제 인덱스 값이 984 인 객체의 이름을 검색하는 방법을 살펴 보겠습니다.

결과 문자열 화

다음과 같이 github 저장소에 URL 객체를 생성합니다.

codes = "https://gist.githubusercontent.com/aaronmarkham/cd3a6b6ac0
71eca6f7b4a6e40e6038aa/raw/9edb4038a37da6b5a44c3b5bc52e448ff09bfe5b/alexnet_codes"

우리는 URL의 내용을 읽습니다-

response = urllib2.urlopen(codes)

응답에는 모든 코드 및 설명 목록이 포함됩니다. 여기에 포함 된 내용을 이해하기 위해 응답의 몇 줄이 아래에 나와 있습니다.

5: 'electric ray, crampfish, numbfish, torpedo',
6: 'stingray',
7: 'cock',
8: 'hen',
9: 'ostrich, Struthio camelus',
10: 'brambling, Fringilla montifringilla',

이제 전체 배열을 반복하여 원하는 코드 984를 찾습니다. for 다음과 같이 루프-

for line in response:
   mystring = line.decode('ascii')
   code, result = mystring.partition(":")[::2]
   code = code.strip()
   result = result.replace("'", "")
   if (code == str(curr_pred)):
      name = result.split(",")[0][1:]
      print("Model predicts", name, "with", curr_conf, "confidence")

코드를 실행하면 다음 출력이 표시됩니다.

Model predicts rapeseed with 0.89235985 confidence

이제 다른 이미지에서 모델을 사용해 볼 수 있습니다.

다른 이미지 예측

다른 이미지를 예측하려면 이미지 파일을 images프로젝트 디렉토리의 폴더. 이것은 우리의 이전tree.jpg파일이 저장됩니다. 코드에서 이미지 파일의 이름을 변경하십시오. 아래와 같이 한 번만 변경하면됩니다.

img = skimage.img_as_float(skimage.io.imread("images/pretzel.jpg")).astype(np.float32)

원본 그림과 예측 결과는 다음과 같습니다.

출력은 아래에 언급되어 있습니다.

Model predicts pretzel with 0.99999976 confidence

보시다시피 사전 훈련 된 모델은 주어진 이미지에서 매우 정확하게 물체를 감지 할 수 있습니다.

전체 소스

주어진 이미지에서 물체 감지를 위해 사전 훈련 된 모델을 사용하는 위 코드의 전체 소스는 빠른 참조를 위해 여기에 언급되어 있습니다.

def crop_image(img,cropx,cropy):
   y,x,c = img.shape
   startx = x//2-(cropx//2)
   starty = y//2-(cropy//2)
   return img[starty:starty+cropy,startx:startx+cropx]
img = skimage.img_as_float(skimage.io.imread("images/pretzel.jpg")).astype(np.float32)
print("Original Image Shape: " , img.shape)
pyplot.figure()
pyplot.imshow(img)
pyplot.title('Original image')
img = resize(img, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE)
print("Image Shape after resizing: " , img.shape)
pyplot.figure()
pyplot.imshow(img)
pyplot.title('Resized image')
img = crop_image(img, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE)
print("Image Shape after cropping: " , img.shape)
pyplot.figure()
pyplot.imshow(img)
pyplot.title('Center Cropped')
img = img.swapaxes(1, 2).swapaxes(0, 1)
print("CHW Image Shape: " , img.shape)
pyplot.figure()
for i in range(3):
pyplot.subplot(1, 3, i+1)
pyplot.imshow(img[i])
pyplot.axis('off')
pyplot.title('RGB channel %d' % (i+1))
# convert RGB --> BGR
img = img[(2, 1, 0), :, :]
# remove mean
img = img * 255 - mean
# add batch size axis
img = img[np.newaxis, :, :, :].astype(np.float32)
CAFFE_MODELS = os.path.expanduser("/anaconda3/lib/python3.7/site-packages/caffe2/python/models")
INIT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'init_net.pb')
PREDICT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'predict_net.pb')
print(INIT_NET)
print(PREDICT_NET)
with open(INIT_NET, "rb") as f:
   init_net = f.read()
with open(PREDICT_NET, "rb") as f:
   predict_net = f.read()
p = workspace.Predictor(init_net, predict_net)
results = p.run({'data': img})
results = np.asarray(results)
print("results shape: ", results.shape)
preds = np.squeeze(results)
curr_pred, curr_conf = max(enumerate(preds), key=operator.itemgetter(1))
print("Prediction: ", curr_pred)
print("Confidence: ", curr_conf)
codes = "https://gist.githubusercontent.com/aaronmarkham/cd3a6b6ac071eca6f7b4a6e40e6038aa/raw/9edb4038a37da6b5a44c3b5bc52e448ff09bfe5b/alexnet_codes"
response = urllib2.urlopen(codes)
for line in response:
   mystring = line.decode('ascii')
   code, result = mystring.partition(":")[::2]
   code = code.strip()
   result = result.replace("'", "")
   if (code == str(curr_pred)):
      name = result.split(",")[0][1:]
      print("Model predicts", name, "with", curr_conf, "confidence")

지금까지 데이터 세트에 대한 예측을 수행하기 위해 사전 학습 된 모델을 사용하는 방법을 알고 있습니다.

다음 단계는 neural network (NN) 아키텍처 Caffe2데이터 세트에 대해 교육합니다. 이제 간단한 단일 레이어 NN을 만드는 방법을 배웁니다.

이 레슨에서는 single layer neural network (NN)Caffe2에서 무작위로 생성 된 데이터 세트에서 실행합니다. 네트워크 아키텍처, 인쇄 입력, 출력, 가중치 및 바이어스 값을 그래픽으로 묘사하는 코드를 작성합니다. 이 강의를 이해하려면 다음에 대해 잘 알고 있어야합니다.neural network architectures, 이것의 terms 과 mathematics 그들에 사용됩니다.

네트워크 아키텍처

아래 그림과 같이 단일 레이어 NN을 구축하고 싶다고 생각해 보겠습니다.

수학적으로이 네트워크는 다음 Python 코드로 표시됩니다.

Y = X * W^T + b

어디 X, W, b 텐서이고 Y출력입니다. 세 개의 텐서 모두를 임의의 데이터로 채우고 네트워크를 실행하고Y산출. 네트워크와 텐서를 정의하기 위해 Caffe2는Operator 기능.

Caffe2 연산자

Caffe2에서는 Operator계산의 기본 단위입니다. 카페 2Operator 다음과 같이 표시됩니다.

Caffe2는 전체 연산자 목록을 제공합니다. 현재 설계중인 네트워크의 경우 입력 벡터를 전달한 결과를 계산하는 FC라는 연산자를 사용합니다.X 2 차원 가중치 행렬을 사용하여 완전히 연결된 네트워크로 W 및 1 차원 편향 벡터 b. 즉, 다음 수학 방정식을 계산합니다.

Y = X * W^T + b

어디 X 치수가 있습니다 (M x k), W 치수가 있습니다 (n x k) 과 b 이다 (1 x n). 출력Y 차원이 될 것입니다 (M x n), 어디 M 배치 크기입니다.

벡터의 경우 X 과 W, 우리는 GaussianFill연산자를 사용하여 임의의 데이터를 만듭니다. 바이어스 값 생성 용b, 우리는 ConstantFill 운영자.

이제 네트워크 정의를 진행하겠습니다.

네트워크 생성

우선, 필요한 패키지를 가져옵니다.

from caffe2.python import core, workspace

다음으로 다음을 호출하여 네트워크를 정의합니다. core.Net 다음과 같이-

net = core.Net("SingleLayerFC")

네트워크 이름은 다음과 같이 지정됩니다. SingleLayerFC. 이때 net이라는 네트워크 개체가 생성됩니다. 지금까지 레이어가 포함되어 있지 않습니다.

텐서 생성

이제 네트워크에 필요한 세 가지 벡터를 생성합니다. 먼저 다음을 호출하여 X 텐서를 생성합니다.GaussianFill 연산자는 다음과 같습니다-

X = net.GaussianFill([], ["X"], mean=0.0, std=1.0, shape=[2, 3], run_once=0)

그만큼 X 벡터에는 치수가 있습니다. 2 x 3 평균 데이터 값 0,0 및 표준 편차 1.0.

마찬가지로 우리는 W 다음과 같이 텐서-

W = net.GaussianFill([], ["W"], mean=0.0, std=1.0, shape=[5, 3], run_once=0)

그만큼 W 벡터의 크기 5 x 3.

마지막으로 우리는 편견을 만듭니다. b 크기 5의 행렬.

b = net.ConstantFill([], ["b"], shape=[5,], value=1.0, run_once=0)

이제 코드에서 가장 중요한 부분은 네트워크 자체를 정의하는 것입니다.

네트워크 정의

다음 Python 문에서 네트워크를 정의합니다.

Y = X.FC([W, b], ["Y"])

우리는 부른다 FC 입력 데이터에 대한 연산자 X. 가중치는Wb의 편향. 출력은Y. 또는 더 자세한 다음 Python 문을 사용하여 네트워크를 만들 수 있습니다.

Y = net.FC([X, W, b], ["Y"])

이 시점에서 네트워크가 생성됩니다. 네트워크를 한 번 이상 실행하기 전까지는 데이터가 포함되지 않습니다. 네트워크를 실행하기 전에 아키텍처를 살펴 보겠습니다.

네트워크 아키텍처 인쇄

Caffe2는 JSON 파일에서 네트워크 아키텍처를 정의하며 생성 된 파일에서 Proto 메서드를 호출하여 검사 할 수 있습니다. net 목적.

print (net.Proto())

이것은 다음과 같은 출력을 생성합니다-

name: "SingleLayerFC"
op {
   output: "X"
   name: ""
   type: "GaussianFill"
   arg {
      name: "mean"
      f: 0.0
   }
   arg {
      name: "std"
      f: 1.0
   }
   arg {
      name: "shape"
      ints: 2
      ints: 3
   }
   arg {
      name: "run_once"
      i: 0
   }
}
op {
   output: "W"
   name: ""
   type: "GaussianFill"
   arg {
      name: "mean"
      f: 0.0
   }
   arg {
      name: "std"
      f: 1.0
   }
   arg {
      name: "shape"
      ints: 5
      ints: 3
   }
   arg {
      name: "run_once"
      i: 0
   }
}
op {
   output: "b"
   name: ""
   type: "ConstantFill"
   arg {
      name: "shape"
      ints: 5
   }
   arg {
      name: "value"
      f: 1.0
   }
   arg {
      name: "run_once"
      i: 0
   }
}
op {
   input: "X"
   input: "W"
   input: "b"
   output: "Y"
   name: ""
   type: "FC"
}

위 목록에서 볼 수 있듯이 먼저 연산자를 정의합니다. X, W 과 b. 의 정의를 살펴 보겠습니다.W예로서. 유형W 다음과 같이 지정됩니다. GausianFill. 그만큼mean float로 정의됩니다. 0.0, 표준 편차는 float로 정의됩니다. 1.0, 그리고 shape 이다 5 x 3.

op {
   output: "W"
   name: "" type: "GaussianFill"
   arg {
      name: "mean" 
	   f: 0.0
   }
   arg { 
      name: "std" 
      f: 1.0
   }
   arg { 
      name: "shape" 
      ints: 5 
      ints: 3
   }
   ...
}

의 정의 검토 X 과 b당신 자신의 이해를 위해. 마지막으로 여기에 재현 된 단일 레이어 네트워크의 정의를 살펴 보겠습니다.

op {
   input: "X"
   input: "W"
   input: "b"
   output: "Y"
   name: ""
   type: "FC"
}

여기서 네트워크 유형은 FC (완전 연결) X, W, b 입력 및 Y출력입니다. 이 네트워크 정의는 너무 장황하고 대규모 네트워크의 경우 내용을 검사하는 것이 지루할 것입니다. 다행히 Caffe2는 생성 된 네트워크에 대한 그래픽 표현을 제공합니다.

네트워크 그래픽 표현

네트워크의 그래픽 표현을 얻으려면 기본적으로 두 줄의 Python 코드 인 다음 코드 조각을 실행합니다.

from caffe2.python import net_drawer
from IPython import display
graph = net_drawer.GetPydotGraph(net, rankdir="LR")
display.Image(graph.create_png(), width=800)

코드를 실행하면 다음 출력이 표시됩니다.

대규모 네트워크의 경우 그래픽 표현은 네트워크 정의 오류를 시각화하고 디버깅하는 데 매우 유용합니다.

마지막으로 이제 네트워크를 실행할 차례입니다.

네트워크 실행

다음을 호출하여 네트워크를 실행합니다. RunNetOnce 에 방법 workspace 객체-

workspace.RunNetOnce(net)

네트워크가 한 번 실행되면 무작위로 생성 된 모든 데이터가 생성되어 네트워크에 공급되고 출력이 생성됩니다. 네트워크 실행 후 생성 된 텐서가 호출됩니다.blobsCaffe2에서. 작업 공간은blobs당신은 메모리에 만들고 저장합니다. 이것은 Matlab과 매우 유사합니다.

네트워크를 실행 한 후 blobs 다음을 사용하여 작업 공간에 포함 된 print 명령

print("Blobs in the workspace: {}".format(workspace.Blobs()))

다음 출력이 표시됩니다.

Blobs in the workspace: ['W', 'X', 'Y', 'b']

작업 공간은 세 개의 입력 blob으로 구성되어 있습니다. X, W 과 b. 또한 다음과 같은 출력 blob을 포함합니다.Y. 이제 이러한 Blob의 내용을 살펴 보겠습니다.

for name in workspace.Blobs():
   print("{}:\n{}".format(name, workspace.FetchBlob(name)))

다음 출력이 표시됩니다.

W:
[[ 1.0426593 0.15479846 0.25635982]
[-2.2461145 1.4581774 0.16827184]
[-0.12009818 0.30771437 0.00791338]
[ 1.2274994 -0.903331 -0.68799865]
[ 0.30834186 -0.53060573 0.88776857]]
X:
[[ 1.6588869e+00 1.5279824e+00 1.1889904e+00]
[ 6.7048723e-01 -9.7490678e-04 2.5114202e-01]]
Y:
[[ 3.2709925 -0.297907 1.2803618 0.837985 1.7562964]
[ 1.7633215 -0.4651525 0.9211631 1.6511179 1.4302125]]
b:
[1. 1. 1. 1. 1.]

모든 입력이 무작위로 생성되기 때문에 컴퓨터의 데이터 또는 네트워크의 모든 실행에 대한 데이터는 다를 수 있습니다. 이제 네트워크를 성공적으로 정의하고 컴퓨터에서 실행했습니다.

이전 단원에서는 사소한 네트워크를 만드는 방법을 배웠고이를 실행하고 출력을 조사하는 방법을 배웠습니다. 복잡한 네트워크를 만드는 프로세스는 위에서 설명한 프로세스와 유사합니다. Caffe2는 복잡한 아키텍처를 만들기위한 거대한 연산자 집합을 제공합니다. 연산자 목록에 대한 Caffe2 문서를 검토하는 것이 좋습니다. 다양한 사업자의 목적을 연구하고 나면 복잡한 네트워크를 만들고 훈련시킬 수있는 위치에있게됩니다. 네트워크 훈련을 위해 Caffe2는predefined computation units-운영자입니다. 해결하려는 문제의 종류에 대해 네트워크를 훈련시키기 위해 적절한 운영자를 선택해야합니다.

네트워크가 만족스럽게 훈련되면 이전에 사용한 사전 훈련 된 모델 파일과 유사한 모델 파일에 저장할 수 있습니다. 이러한 훈련 된 모델은 다른 사용자의 이익을 위해 Caffe2 저장소에 기여할 수 있습니다. 또는 자신의 개인 프로덕션 용도로 훈련 된 모델을 배치 할 수도 있습니다.

요약

딥 러닝 프레임 워크 인 Caffe2를 사용하면 데이터를 예측하기 위해 여러 종류의 신경망을 실험 할 수 있습니다. Caffe2 사이트는 많은 사전 훈련 된 모델을 제공합니다. 주어진 이미지에서 객체를 분류하기 위해 사전 훈련 된 모델 중 하나를 사용하는 방법을 배웠습니다. 또한 선택한 신경망 아키텍처를 정의하는 방법도 배웠습니다. 이러한 사용자 지정 네트워크는 Caffe에서 미리 정의 된 여러 연산자를 사용하여 훈련 할 수 있습니다. 훈련 된 모델은 프로덕션 환경으로 가져올 수있는 파일에 저장됩니다.