CNTK - ในหน่วยความจำและชุดข้อมูลขนาดใหญ่

ในบทนี้เราจะเรียนรู้เกี่ยวกับวิธีการทำงานกับในหน่วยความจำและชุดข้อมูลขนาดใหญ่ใน CNTK

การฝึกอบรมด้วยชุดข้อมูลหน่วยความจำขนาดเล็ก

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

ในส่วนนี้เราจะทำงานกับชุดข้อมูลในหน่วยความจำ สำหรับสิ่งนี้เราจะใช้สองกรอบต่อไปนี้ -

• Numpy
• Pandas

การใช้อาร์เรย์ Numpy

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

ตัวอย่างการใช้งาน

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

Step 1 - นำเข้าไฟล์ numpy แพคเกจดังนี้ -

import numpy as np
num_samples = 20000

Step 2 - จากนั้นสร้างการแมปฉลากโดยใช้ np.eye ฟังก์ชันดังต่อไปนี้ -

label_mapping = np.eye(2)

Step 3 - ตอนนี้โดยใช้ np.random.choice ฟังก์ชั่นรวบรวม 20000 ตัวอย่างสุ่มดังต่อไปนี้ -

y = label_mapping[np.random.choice(2,num_samples)].astype(np.float32)

Step 4 - ในที่สุดโดยใช้ฟังก์ชัน np.random.random สร้างอาร์เรย์ของค่าทศนิยมแบบสุ่มดังนี้ -

x = np.random.random(size=(num_samples, 4)).astype(np.float32)

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

Step 5 - นำเข้าฟังก์ชันเลเยอร์หนาแน่นและตามลำดับจากโมดูล cntk.layers ดังนี้ -

from cntk.layers import Dense, Sequential

Step 6- ตอนนี้เราต้องนำเข้าฟังก์ชันการเปิดใช้งานสำหรับเลเยอร์ในเครือข่าย ให้เรานำเข้าไฟล์sigmoid เป็นฟังก์ชันการเปิดใช้งาน -

from cntk import input_variable, default_options
from cntk.ops import sigmoid

Step 7- ตอนนี้เราจำเป็นต้องนำเข้าฟังก์ชันการสูญเสียเพื่อฝึกอบรมเครือข่าย ให้เรานำเข้าbinary_cross_entropy เป็นฟังก์ชันการสูญเสีย -

from cntk.losses import binary_cross_entropy

Step 8- ต่อไปเราต้องกำหนดตัวเลือกเริ่มต้นสำหรับเครือข่าย ที่นี่เราจะให้บริการsigmoidฟังก์ชันการเปิดใช้งานเป็นการตั้งค่าเริ่มต้น สร้างโมเดลโดยใช้ฟังก์ชัน Sequential Layer ดังนี้ -

with default_options(activation=sigmoid):
model = Sequential([Dense(6),Dense(2)])

Step 9 - ถัดไปเริ่มต้นไฟล์ input_variable ด้วยคุณสมบัติการป้อนข้อมูล 4 แบบที่ทำหน้าที่เป็นอินพุตสำหรับเครือข่าย

features = input_variable(4)

Step 10 - ตอนนี้เพื่อให้เสร็จสมบูรณ์เราจำเป็นต้องเชื่อมต่อตัวแปรคุณสมบัติกับ NN

z = model(features)

ดังนั้นตอนนี้เรามี NN แล้วด้วยความช่วยเหลือของขั้นตอนต่อไปนี้ให้เราฝึกมันโดยใช้ชุดข้อมูลในหน่วยความจำ -

Step 11 - ในการฝึกอบรม NN นี้อันดับแรกเราต้องนำเข้าผู้เรียนจาก cntk.learnersโมดูล. เราจะนำเข้าsgd ผู้เรียนดังนี้ -

from cntk.learners import sgd

Step 12 - พร้อมกับการนำเข้าไฟล์ ProgressPrinter จาก cntk.logging โมดูลด้วย

from cntk.logging import ProgressPrinter
progress_writer = ProgressPrinter(0)

Step 13 - จากนั้นกำหนดตัวแปรอินพุตใหม่สำหรับป้ายกำกับดังนี้ -

labels = input_variable(2)

Step 14 - ในการฝึกโมเดล NN ต่อไปเราต้องกำหนดการสูญเสียโดยใช้ binary_cross_entropyฟังก์ชัน นอกจากนี้ให้ระบุโมเดล z และตัวแปรเลเบล

loss = binary_cross_entropy(z, labels)

Step 15 - ถัดไปเริ่มต้น sgd ผู้เรียนดังนี้ -

learner = sgd(z.parameters, lr=0.1)

Step 16- ในที่สุดเรียกวิธีการรถไฟในฟังก์ชั่นการสูญเสีย นอกจากนี้ให้ใส่ข้อมูลอินพุตไฟล์sgd ผู้เรียนและ progress_printer.−

training_summary=loss.train((x,y),parameter_learners=[learner],callbacks=[progress_writer])

ตัวอย่างการใช้งานที่สมบูรณ์

import numpy as np
num_samples = 20000
label_mapping = np.eye(2)
y = label_mapping[np.random.choice(2,num_samples)].astype(np.float32)
x = np.random.random(size=(num_samples, 4)).astype(np.float32)
from cntk.layers import Dense, Sequential
from cntk import input_variable, default_options
from cntk.ops import sigmoid
from cntk.losses import binary_cross_entropy
with default_options(activation=sigmoid):
   model = Sequential([Dense(6),Dense(2)])
features = input_variable(4)
z = model(features)
from cntk.learners import sgd
from cntk.logging import ProgressPrinter
progress_writer = ProgressPrinter(0)
labels = input_variable(2)
loss = binary_cross_entropy(z, labels)
learner = sgd(z.parameters, lr=0.1)
training_summary=loss.train((x,y),parameter_learners=[learner],callbacks=[progress_writer])

เอาต์พุต

Build info:
     Built time: *** ** **** 21:40:10
     Last modified date: *** *** ** 21:08:46 2019
     Build type: Release
     Build target: CPU-only
     With ASGD: yes
     Math lib: mkl
     Build Branch: HEAD
     Build SHA1:ae9c9c7c5f9e6072cc9c94c254f816dbdc1c5be6 (modified)
     MPI distribution: Microsoft MPI
     MPI version: 7.0.12437.6
-------------------------------------------------------------------
average   since   average   since examples
loss      last    metric    last
------------------------------------------------------
Learning rate per minibatch: 0.1
1.52      1.52      0         0     32
1.51      1.51      0         0     96
1.48      1.46      0         0    224
1.45      1.42      0         0    480
1.42       1.4      0         0    992
1.41      1.39      0         0   2016
1.4       1.39      0         0   4064
1.39      1.39      0         0   8160
1.39      1.39      0         0  16352

การใช้ Pandas DataFrames

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

หนึ่งในไลบรารี Python ที่เรียกว่า Pandas ช่วยให้ทำงานกับชุดข้อมูลประเภทนี้ได้ง่ายขึ้น แนะนำแนวคิดของ DataFrame (DF) และช่วยให้เราโหลดชุดข้อมูลจากดิสก์ที่จัดเก็บในรูปแบบต่างๆเป็น DF ตัวอย่างเช่นเราสามารถอ่าน DF ที่จัดเก็บเป็น CSV, JSON, Excel เป็นต้น

คุณสามารถเรียนรู้ไลบรารี Python Pandas โดยละเอียดได้ที่ https://www.tutorialspoint.com/python_pandas/index.htm.

ตัวอย่างการใช้งาน

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

from cntk.layers import Dense, Sequential
from cntk import input_variable, default_options
from cntk.ops import sigmoid, log_softmax
from cntk.losses import binary_cross_entropy
model = Sequential([
Dense(4, activation=sigmoid),
Dense(3, activation=log_softmax)
])
features = input_variable(4)
z = model(features)

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

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

Step 1 - นำเข้าไฟล์ numpy และ Pandas แพคเกจดังนี้ -

import numpy as np
import pandas as pd

Step 2 - ถัดไปใช้ read_csv ฟังก์ชั่นโหลดชุดข้อมูลลงในหน่วยความจำ -

df_source = pd.read_csv(‘iris.csv’, names = [‘sepal_length’, ‘sepal_width’,
 ‘petal_length’, ‘petal_width’, ‘species’], index_col=False)

Step 3 - ตอนนี้เราต้องสร้างพจนานุกรมที่จะทำแผนที่ป้ายกำกับในชุดข้อมูลด้วยการแสดงตัวเลขที่สอดคล้องกัน

label_mapping = {‘Iris-Setosa’ : 0, ‘Iris-Versicolor’ : 1, ‘Iris-Virginica’ : 2}

Step 4 - ตอนนี้โดยใช้ iloc ตัวทำดัชนีบน DataFrameเลือกสี่คอลัมน์แรกดังนี้ -

x = df_source.iloc[:, :4].values

Step 5− ถัดไปเราต้องเลือกคอลัมน์สายพันธุ์เป็นป้ายกำกับสำหรับชุดข้อมูล สามารถทำได้ดังนี้ -

y = df_source[‘species’].values

Step 6 - ตอนนี้เราต้องแมปป้ายกำกับในชุดข้อมูลซึ่งสามารถทำได้โดยใช้ label_mapping. นอกจากนี้ให้ใช้one_hot การเข้ารหัสเพื่อแปลงเป็นอาร์เรย์การเข้ารหัสแบบร้อนเดียว

y = np.array([one_hot(label_mapping[v], 3) for v in y])

Step 7 - ถัดไปในการใช้คุณสมบัติและป้ายกำกับที่แมปกับ CNTK เราจำเป็นต้องแปลงทั้งคู่เป็นลอย -

x= x.astype(np.float32)
y= y.astype(np.float32)

ดังที่เราทราบดีว่าเลเบลจะถูกเก็บไว้ในชุดข้อมูลเป็นสตริงและ CNTK ไม่สามารถทำงานกับสตริงเหล่านี้ได้ นั่นเป็นเหตุผลว่าทำไมจึงต้องใช้เวกเตอร์ที่เข้ารหัสแบบร้อนเดียวซึ่งแสดงถึงป้ายกำกับ สำหรับสิ่งนี้เราสามารถกำหนดฟังก์ชันพูดได้one_hot ดังต่อไปนี้ -

def one_hot(index, length):
result = np.zeros(length)
result[index] = index
return result

ตอนนี้เรามีอาร์เรย์ numpy ในรูปแบบที่ถูกต้องด้วยความช่วยเหลือของขั้นตอนต่อไปนี้เราสามารถใช้มันเพื่อฝึกโมเดลของเรา -

Step 8- ก่อนอื่นเราต้องนำเข้าฟังก์ชันการสูญเสียเพื่อฝึกอบรมเครือข่าย ให้เรานำเข้าbinary_cross_entropy_with_softmax เป็นฟังก์ชันการสูญเสีย -

from cntk.losses import binary_cross_entropy_with_softmax

Step 9 - ในการฝึกอบรม NN นี้เราจำเป็นต้องนำเข้าผู้เรียนจาก cntk.learnersโมดูล. เราจะนำเข้าsgd ผู้เรียนดังนี้ -

from cntk.learners import sgd

Step 10 - พร้อมกับการนำเข้าไฟล์ ProgressPrinter จาก cntk.logging โมดูลด้วย

from cntk.logging import ProgressPrinter
progress_writer = ProgressPrinter(0)

Step 11 - จากนั้นกำหนดตัวแปรอินพุตใหม่สำหรับป้ายกำกับดังนี้ -

labels = input_variable(3)

Step 12 - ในการฝึกโมเดล NN ต่อไปเราต้องกำหนดการสูญเสียโดยใช้ binary_cross_entropy_with_softmaxฟังก์ชัน ระบุโมเดล z และตัวแปรเลเบลด้วย

loss = binary_cross_entropy_with_softmax (z, labels)

Step 13 - ถัดไปเริ่มต้น sgd ผู้เรียนดังนี้ -

learner = sgd(z.parameters, 0.1)

Step 14- ในที่สุดเรียกวิธีการรถไฟในฟังก์ชั่นการสูญเสีย นอกจากนี้ให้ใส่ข้อมูลอินพุตไฟล์sgd ผู้เรียนและ progress_printer.

training_summary=loss.train((x,y),parameter_learners=[learner],callbacks=
[progress_writer],minibatch_size=16,max_epochs=5)

ตัวอย่างการใช้งานที่สมบูรณ์

from cntk.layers import Dense, Sequential
from cntk import input_variable, default_options
from cntk.ops import sigmoid, log_softmax
from cntk.losses import binary_cross_entropy
model = Sequential([
Dense(4, activation=sigmoid),
Dense(3, activation=log_softmax)
])
features = input_variable(4)
z = model(features)
import numpy as np
import pandas as pd
df_source = pd.read_csv(‘iris.csv’, names = [‘sepal_length’, ‘sepal_width’, ‘petal_length’, ‘petal_width’, ‘species’], index_col=False)
label_mapping = {‘Iris-Setosa’ : 0, ‘Iris-Versicolor’ : 1, ‘Iris-Virginica’ : 2}
x = df_source.iloc[:, :4].values
y = df_source[‘species’].values
y = np.array([one_hot(label_mapping[v], 3) for v in y])
x= x.astype(np.float32)
y= y.astype(np.float32)
def one_hot(index, length):
result = np.zeros(length)
result[index] = index
return result
from cntk.losses import binary_cross_entropy_with_softmax
from cntk.learners import sgd
from cntk.logging import ProgressPrinter
progress_writer = ProgressPrinter(0)
labels = input_variable(3)
loss = binary_cross_entropy_with_softmax (z, labels)
learner = sgd(z.parameters, 0.1)
training_summary=loss.train((x,y),parameter_learners=[learner],callbacks=[progress_writer],minibatch_size=16,max_epochs=5)

เอาต์พุต

Build info:
     Built time: *** ** **** 21:40:10
     Last modified date: *** *** ** 21:08:46 2019
     Build type: Release
     Build target: CPU-only
     With ASGD: yes
     Math lib: mkl
     Build Branch: HEAD
     Build SHA1:ae9c9c7c5f9e6072cc9c94c254f816dbdc1c5be6 (modified)
     MPI distribution: Microsoft MPI
     MPI version: 7.0.12437.6
-------------------------------------------------------------------
average    since    average   since   examples
loss        last     metric   last
------------------------------------------------------
Learning rate per minibatch: 0.1
1.1         1.1        0       0      16
0.835     0.704        0       0      32
1.993      1.11        0       0      48
1.14       1.14        0       0     112
[………]

การฝึกอบรมกับชุดข้อมูลขนาดใหญ่

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

• MinibatchSource สามารถป้องกัน NN จากการติดตั้งมากเกินไปโดยสุ่มตัวอย่างโดยอัตโนมัติที่อ่านจากแหล่งข้อมูล

• มีท่อส่งการแปลงในตัวซึ่งสามารถใช้เพื่อเพิ่มข้อมูลได้

• โหลดข้อมูลบนเธรดพื้นหลังแยกต่างหากจากกระบวนการฝึกอบรม

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

การสร้างอินสแตนซ์ MinibatchSource

ในส่วนก่อนหน้านี้เราได้ใช้ตัวอย่างดอกไอริสและทำงานกับชุดข้อมูลในหน่วยความจำขนาดเล็กโดยใช้ Pandas DataFrames ที่นี่เราจะแทนที่โค้ดที่ใช้ข้อมูลจากแพนด้า DF ด้วยMinibatchSource. ขั้นแรกเราต้องสร้างอินสแตนซ์ของMinibatchSource ด้วยความช่วยเหลือของขั้นตอนต่อไปนี้ -

ตัวอย่างการใช้งาน

Step 1 - อันดับแรกจาก cntk.io โมดูลนำเข้าส่วนประกอบสำหรับมินิแบทช์ซอร์สดังนี้ -

from cntk.io import StreamDef, StreamDefs, MinibatchSource, CTFDeserializer,
 INFINITY_REPEAT

Step 2 - ตอนนี้โดยใช้ StreamDef คลาสสร้างนิยามสตรีมสำหรับป้ายกำกับ

labels_stream = StreamDef(field=’labels’, shape=3, is_sparse=False)

Step 3 - จากนั้นสร้างเพื่ออ่านคุณสมบัติที่ยื่นจากไฟล์อินพุตสร้างอินสแตนซ์อื่นของ StreamDef ดังต่อไปนี้.

feature_stream = StreamDef(field=’features’, shape=4, is_sparse=False)

Step 4 - ตอนนี้เราจำเป็นต้องให้ iris.ctf ไฟล์เป็นอินพุตและเริ่มต้นไฟล์ deserializer ดังต่อไปนี้ -

deserializer = CTFDeserializer(‘iris.ctf’, StreamDefs(labels=
label_stream, features=features_stream)

Step 5 - ในที่สุดเราต้องสร้างอินสแตนซ์ของ minisourceBatch โดยใช้ deserializer ดังต่อไปนี้ -

Minibatch_source = MinibatchSource(deserializer, randomize=True)

การสร้างอินสแตนซ์ MinibatchSource - ตัวอย่างการใช้งานที่สมบูรณ์

from cntk.io import StreamDef, StreamDefs, MinibatchSource, CTFDeserializer, INFINITY_REPEAT
labels_stream = StreamDef(field=’labels’, shape=3, is_sparse=False)
feature_stream = StreamDef(field=’features’, shape=4, is_sparse=False)
deserializer = CTFDeserializer(‘iris.ctf’, StreamDefs(labels=label_stream, features=features_stream)
Minibatch_source = MinibatchSource(deserializer, randomize=True)

การสร้างไฟล์ MCTF

ดังที่คุณได้เห็นข้างต้นเรากำลังนำข้อมูลจากไฟล์ "iris.ctf" มีรูปแบบไฟล์ที่เรียกว่า CNTK Text Format (CTF) จำเป็นต้องสร้างไฟล์ CTF เพื่อรับข้อมูลสำหรับไฟล์MinibatchSourceอินสแตนซ์ที่เราสร้างไว้ข้างต้น มาดูกันว่าเราจะสร้างไฟล์ CTF ได้อย่างไร

ตัวอย่างการใช้งาน

Step 1 - ก่อนอื่นเราต้องนำเข้าแพนด้าและแพคเกจ numpy ดังนี้ -

import pandas as pd
import numpy as np

Step 2- ต่อไปเราต้องโหลดไฟล์ข้อมูลของเราคือ iris.csv ลงในหน่วยความจำ จากนั้นเก็บไว้ในไฟล์df_source ตัวแปร.

df_source = pd.read_csv(‘iris.csv’, names = [‘sepal_length’, ‘sepal_width’, ‘petal_length’, ‘petal_width’, ‘species’], index_col=False)

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

features = df_source.iloc[: , :4].values
labels = df_source[‘species’].values

Step 4- ต่อไปเราต้องสร้างการจับคู่ระหว่างชื่อป้ายกำกับและการแสดงตัวเลข สามารถทำได้โดยการสร้างlabel_mapping ดังต่อไปนี้ -

label_mapping = {‘Iris-Setosa’ : 0, ‘Iris-Versicolor’ : 1, ‘Iris-Virginica’ : 2}

Step 5 - ตอนนี้ให้แปลงป้ายกำกับเป็นชุดเวกเตอร์ที่เข้ารหัสแบบร้อนเดียวดังนี้ -

labels = [one_hot(label_mapping[v], 3) for v in labels]

ตอนนี้อย่างที่เราเคยทำมาก่อนสร้างฟังก์ชันยูทิลิตี้ที่เรียกว่า one_hotเพื่อเข้ารหัสฉลาก สามารถทำได้ดังนี้ -

def one_hot(index, length):
result = np.zeros(length)
result[index] = 1
return result

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

With open(‘iris.ctf’, ‘w’) as output_file:
for index in range(0, feature.shape[0]):
feature_values = ‘ ‘.join([str(x) for x in np.nditer(features[index])])
label_values = ‘ ‘.join([str(x) for x in np.nditer(labels[index])])
output_file.write(‘features {} | labels {} \n’.format(feature_values, label_values))

การสร้างไฟล์ MCTF - ตัวอย่างการใช้งานที่สมบูรณ์

import pandas as pd
import numpy as np
df_source = pd.read_csv(‘iris.csv’, names = [‘sepal_length’, ‘sepal_width’, ‘petal_length’, ‘petal_width’, ‘species’], index_col=False)
features = df_source.iloc[: , :4].values
labels = df_source[‘species’].values
label_mapping = {‘Iris-Setosa’ : 0, ‘Iris-Versicolor’ : 1, ‘Iris-Virginica’ : 2}
labels = [one_hot(label_mapping[v], 3) for v in labels]
def one_hot(index, length):
result = np.zeros(length)
result[index] = 1
return result
With open(‘iris.ctf’, ‘w’) as output_file:
for index in range(0, feature.shape[0]):
feature_values = ‘ ‘.join([str(x) for x in np.nditer(features[index])])
label_values = ‘ ‘.join([str(x) for x in np.nditer(labels[index])])
output_file.write(‘features {} | labels {} \n’.format(feature_values, label_values))

การป้อนข้อมูล

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

ตัวอย่างการใช้งาน

Step 1 - ในการบันทึกผลลัพธ์ของเซสชันการฝึกอบรมขั้นแรกให้นำเข้า ProgressPrinter จาก cntk.logging โมดูลดังนี้ -

from cntk.logging import ProgressPrinter

Step 2 - ถัดไปในการตั้งค่าเซสชันการฝึกอบรมให้นำเข้าไฟล์ trainer และ training_session จาก cntk.train โมดูลดังนี้ -

from cntk.train import Trainer,

Step 3 - ตอนนี้เราต้องกำหนดชุดค่าคงที่เช่น minibatch_size, samples_per_epoch และ num_epochs ดังต่อไปนี้ -

minbatch_size = 16
samples_per_epoch = 150
num_epochs = 30

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

input_map = {
     features: minibatch.source.streams.features,
     labels: minibatch.source.streams.features
}

Step 5 - ถัดไปในการบันทึกผลลัพธ์ของกระบวนการฝึกอบรมให้เริ่มต้นไฟล์ progress_printer ตัวแปรด้วยไฟล์ ProgressPrinter อินสแตนซ์ดังนี้ -

progress_writer = ProgressPrinter(0)

Step 6 - ในที่สุดเราต้องเรียกใช้วิธีการรถไฟในการสูญเสียดังต่อไปนี้ -

train_history = loss.train(minibatch_source,
parameter_learners=[learner],
  model_inputs_to_streams=input_map,
callbacks=[progress_writer],
epoch_size=samples_per_epoch,
max_epochs=num_epochs)

การป้อนข้อมูล - ตัวอย่างการใช้งานที่สมบูรณ์

from cntk.logging import ProgressPrinter
from cntk.train import Trainer, training_session
minbatch_size = 16
samples_per_epoch = 150
num_epochs = 30
input_map = {
   features: minibatch.source.streams.features,
   labels: minibatch.source.streams.features
}
progress_writer = ProgressPrinter(0)
train_history = loss.train(minibatch_source,
parameter_learners=[learner],
model_inputs_to_streams=input_map,
callbacks=[progress_writer],
epoch_size=samples_per_epoch,
max_epochs=num_epochs)

เอาต์พุต

-------------------------------------------------------------------
average   since   average   since  examples
loss      last     metric   last
------------------------------------------------------
Learning rate per minibatch: 0.1
1.21      1.21      0        0       32
1.15      0.12      0        0       96
[………]