Caffe2 - การสร้างเครือข่ายของคุณเอง

ในบทเรียนนี้คุณจะได้เรียนรู้การกำหนด a 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 Operators

ใน Caffe2 Operatorเป็นหน่วยพื้นฐานของการคำนวณ คาเฟ่ 2Operator แสดงเป็นดังนี้

Caffe2 ให้รายชื่อผู้ดำเนินการโดยละเอียด สำหรับเครือข่ายที่เรากำลังออกแบบอยู่ในขณะนี้เราจะใช้ตัวดำเนินการที่เรียกว่า FC ซึ่งคำนวณผลลัพธ์ของการส่งเวกเตอร์อินพุตX เข้าสู่เครือข่ายที่เชื่อมต่ออย่างสมบูรณ์ด้วยเมทริกซ์น้ำหนักสองมิติ W และเวกเตอร์อคติมิติเดียว 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 ถูกสร้างขึ้น ยังไม่มีเลเยอร์ใด ๆ เลย

การสร้าง Tensors

ตอนนี้เราจะสร้างเวกเตอร์สามตัวที่เครือข่ายของเราต้องการ ขั้นแรกเราจะสร้าง X tensor โดยการโทร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. มีการระบุน้ำหนักไว้ในWและอคติใน b. ผลลัพธ์คือ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 ถูกกำหนดให้เป็นลอย 0.0ค่าเบี่ยงเบนมาตรฐานถูกกำหนดให้เป็นลอย 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)

หลังจากเรียกใช้เครือข่ายครั้งเดียวข้อมูลทั้งหมดของเราที่สร้างขึ้นแบบสุ่มจะถูกสร้างป้อนเข้าสู่เครือข่ายและผลลัพธ์จะถูกสร้างขึ้น เรียกว่าเทนเซอร์ที่สร้างขึ้นหลังจากรันเครือข่ายblobsใน Caffe2. พื้นที่ทำงานประกอบด้วยไฟล์blobsคุณสร้างและเก็บไว้ในหน่วยความจำ ซึ่งค่อนข้างคล้ายกับ Matlab

หลังจากเรียกใช้เครือข่ายคุณสามารถตรวจสอบไฟล์ blobs ที่พื้นที่ทำงานมีโดยใช้สิ่งต่อไปนี้ print คำสั่ง

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

คุณจะเห็นผลลัพธ์ต่อไปนี้ -

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

โปรดทราบว่าพื้นที่ทำงานประกอบด้วยช่องป้อนข้อมูลสามช่อง - X, W และ b. นอกจากนี้ยังมีหยดเอาต์พุตที่เรียกว่าY. ตอนนี้ให้เราตรวจสอบเนื้อหาของ blobs เหล่านี้

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.]

โปรดทราบว่าข้อมูลในเครื่องของคุณหรือตามความเป็นจริงในทุกการทำงานของเครือข่ายจะแตกต่างกันเนื่องจากอินพุตทั้งหมดถูกสร้างขึ้นแบบสุ่ม ขณะนี้คุณได้กำหนดเครือข่ายสำเร็จแล้วและเรียกใช้บนคอมพิวเตอร์ของคุณ