Caffe2 - Tạo mạng của riêng bạn
Trong bài học này, bạn sẽ học cách xác định single layer neural network (NN)trong Caffe2 và chạy nó trên tập dữ liệu được tạo ngẫu nhiên. Chúng tôi sẽ viết mã để mô tả bằng đồ thị kiến trúc mạng, in các giá trị đầu vào, đầu ra, trọng số và độ lệch. Để hiểu bài học này, bạn phải làm quen vớineural network architectures, nó là terms và mathematics được sử dụng trong chúng.
Kiến trúc mạng
Chúng ta hãy xem xét rằng chúng ta muốn xây dựng một lớp NN đơn lẻ như trong hình bên dưới -
Về mặt toán học, mạng này được biểu diễn bằng mã Python sau:
Y = X * W^T + b
Ở đâu X, W, b là căng thẳng và Ylà đầu ra. Chúng tôi sẽ điền vào tất cả ba tensor bằng một số dữ liệu ngẫu nhiên, chạy mạng và kiểm traYđầu ra. Để xác định mạng và bộ căng, Caffe2 cung cấp một sốOperator chức năng.
Nhà điều hành Caffe2
Trong Caffe2, Operatorlà đơn vị cơ bản của tính toán. The Caffe2Operator được biểu diễn như sau.
Caffe2 cung cấp một danh sách đầy đủ các nhà khai thác. Đối với mạng mà chúng tôi đang thiết kế hiện tại, chúng tôi sẽ sử dụng toán tử có tên FC, toán tử này tính toán kết quả của việc truyền một vectơ đầu vàoX thành một mạng được kết nối đầy đủ với ma trận trọng số hai chiều W và một vectơ thiên vị một chiều b. Nói cách khác, nó tính toán phương trình toán học sau
Y = X * W^T + b
Ở đâu X có kích thước (M x k), W có kích thước (n x k) và b Là (1 x n). Đầu raY sẽ có kích thước (M x n), Ở đâu M là kích thước lô.
Đối với các vectơ X và W, chúng tôi sẽ sử dụng GaussianFilltoán tử để tạo một số dữ liệu ngẫu nhiên. Để tạo giá trị thiên vịb, chúng tôi sẽ sử dụng ConstantFill nhà điều hành.
Bây giờ chúng ta sẽ tiến hành xác định mạng của chúng ta.
Tạo mạng
Trước hết, hãy nhập các gói được yêu cầu -
from caffe2.python import core, workspace
Tiếp theo, xác định mạng bằng cách gọi core.Net như sau -
net = core.Net("SingleLayerFC")
Tên của mạng được chỉ định là SingleLayerFC. Tại thời điểm này, đối tượng mạng được gọi là net được tạo ra. Nó không chứa bất kỳ lớp nào cho đến nay.
Tạo độ căng
Bây giờ chúng ta sẽ tạo ba vectơ mà mạng của chúng ta yêu cầu. Đầu tiên, chúng ta sẽ tạo tensor X bằng cách gọiGaussianFill toán tử như sau -
X = net.GaussianFill([], ["X"], mean=0.0, std=1.0, shape=[2, 3], run_once=0)
Các X vector có kích thước 2 x 3 với giá trị dữ liệu trung bình là 0,0 và độ lệch chuẩn là 1.0.
Tương tự như vậy, chúng tôi tạo W tensor như sau -
W = net.GaussianFill([], ["W"], mean=0.0, std=1.0, shape=[5, 3], run_once=0)
Các W vectơ có kích thước 5 x 3.
Cuối cùng, chúng tôi tạo ra sự thiên vị b ma trận có kích thước 5.
b = net.ConstantFill([], ["b"], shape=[5,], value=1.0, run_once=0)
Bây giờ, đến phần quan trọng nhất của mã và đó là xác định chính mạng.
Xác định mạng
Chúng tôi xác định mạng trong câu lệnh Python sau:
Y = X.FC([W, b], ["Y"])
Chúng tôi gọi FC toán tử trên dữ liệu đầu vào X. Các trọng lượng được chỉ định trongWvà thiên vị trong b. Đầu ra làY. Ngoài ra, bạn có thể tạo mạng bằng cách sử dụng câu lệnh Python sau, câu này dài dòng hơn.
Y = net.FC([X, W, b], ["Y"])
Tại thời điểm này, mạng được tạo đơn giản. Cho đến khi chúng tôi chạy mạng ít nhất một lần, nó sẽ không chứa bất kỳ dữ liệu nào. Trước khi chạy mạng, chúng tôi sẽ kiểm tra kiến trúc của nó.
Kiến trúc mạng in
Caffe2 xác định kiến trúc mạng trong tệp JSON, có thể được kiểm tra bằng cách gọi phương thức Proto trên tệp đã tạo net vật.
print (net.Proto())
Điều này tạo ra kết quả sau:
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"
}
Như bạn có thể thấy trong danh sách trên, trước tiên nó xác định các toán tử X, W và b. Hãy để chúng tôi xem xét định nghĩa củaWnhư một ví dụ. LoạiW được chỉ định là GausianFill. Cácmean được định nghĩa là float 0.0, độ lệch chuẩn được định nghĩa là float 1.0, và shape Là 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
}
...
}
Kiểm tra các định nghĩa của X và bcho sự hiểu biết của riêng bạn. Cuối cùng, chúng ta hãy xem định nghĩa của mạng lớp đơn của chúng tôi, được tái tạo ở đây
op {
input: "X"
input: "W"
input: "b"
output: "Y"
name: ""
type: "FC"
}
Đây, loại mạng là FC (Kết nối đầy đủ) với X, W, b làm đầu vào và Ylà đầu ra. Định nghĩa mạng này quá dài dòng và đối với các mạng lớn, việc kiểm tra nội dung của nó sẽ trở nên tẻ nhạt. May mắn thay, Caffe2 cung cấp một biểu diễn đồ họa cho các mạng đã tạo.
Biểu diễn đồ họa mạng
Để có được biểu diễn đồ họa của mạng, hãy chạy đoạn mã sau, về cơ bản chỉ là hai dòng mã 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)
Khi bạn chạy mã, bạn sẽ thấy kết quả sau:
Đối với các mạng lớn, biểu diễn đồ họa trở nên cực kỳ hữu ích trong việc trực quan hóa và gỡ lỗi định nghĩa mạng.
Cuối cùng, bây giờ là lúc để chạy mạng.
Mạng đang chạy
Bạn chạy mạng bằng cách gọi RunNetOnce phương pháp trên workspace đối tượng -
workspace.RunNetOnce(net)
Sau khi mạng được chạy một lần, tất cả dữ liệu của chúng tôi được tạo ngẫu nhiên sẽ được tạo, đưa vào mạng và đầu ra sẽ được tạo. Các tenxơ được tạo ra sau khi chạy mạng được gọi làblobstrong Caffe2. Không gian làm việc bao gồmblobsbạn tạo và lưu trữ trong bộ nhớ. Điều này khá giống với Matlab.
Sau khi chạy mạng, bạn có thể kiểm tra blobs mà không gian làm việc chứa bằng cách sử dụng print chỉ huy
print("Blobs in the workspace: {}".format(workspace.Blobs()))
Bạn sẽ thấy kết quả sau:
Blobs in the workspace: ['W', 'X', 'Y', 'b']
Lưu ý rằng không gian làm việc bao gồm ba đốm màu đầu vào - X, W và b. Nó cũng chứa blob đầu ra được gọi làY. Bây giờ chúng ta hãy kiểm tra nội dung của những đốm màu này.
for name in workspace.Blobs():
print("{}:\n{}".format(name, workspace.FetchBlob(name)))
Bạn sẽ thấy kết quả sau:
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.]
Lưu ý rằng dữ liệu trên máy của bạn hoặc thực tế là trên mỗi lần chạy mạng sẽ khác nhau vì tất cả các đầu vào được tạo ngẫu nhiên. Bây giờ bạn đã xác định thành công một mạng và chạy nó trên máy tính của mình.