Trong các phần trước, chúng tôi đã thảo luận về các phương pháp khác nhau để xác thực hiệu suất của NN, nhưng các phương pháp chúng tôi đã thảo luận là những phương pháp xử lý các tập dữ liệu phù hợp với bộ nhớ.
Ở đây, câu hỏi đặt ra là còn các tập dữ liệu hết bộ nhớ thì sao, vì trong kịch bản sản xuất, chúng tôi cần rất nhiều dữ liệu để huấn luyện NN. Trong phần này, chúng ta sẽ thảo luận cách đo lường hiệu suất khi làm việc với các nguồn minibatch và vòng lặp minibatch thủ công.
Nguồn minibatch
Trong khi làm việc với tập dữ liệu hết bộ nhớ, tức là các nguồn minibatch, chúng tôi cần thiết lập về tổn thất cũng như số liệu hơi khác so với thiết lập mà chúng tôi đã sử dụng khi làm việc với các tập dữ liệu nhỏ, tức là tập dữ liệu trong bộ nhớ. Đầu tiên, chúng ta sẽ xem cách thiết lập cách cung cấp dữ liệu cho người huấn luyện mô hình NN.
Sau đây là các bước triển khai−
Bước 1 − Đầu tiên, từ mô-đun cntk.io nhập các thành phần để tạo nguồn minibatch như sau− from cntk.io import StreamDef, StreamDefs, MinibatchSource, CTFDeserializer, INFINITY_REPEAT
Bước 2 − Tiếp theo, tạo một hàm mới có tên là create_datasource. Hàm này sẽ có hai tham số là tên tệp và giới hạn, với giá trị mặc định là INFINITELY_REPEAT. def create_datasource(filename, limit =INFINITELY_REPEAT)
Bước 3 − Bây giờ, trong hàm, bằng cách sử dụng lớp StreamDef tạo ra một định nghĩa luồng cho các nhãn đọc từ trường nhãn có ba tính năng. Chúng ta cũng cần đặt is_sparse thành False như sau− labels_stream = StreamDef(field=’labels’, shape=3, is_sparse=False)
Bước 4 − Tiếp theo, tạo để đọc các tính năng được cung cấp từ tệp đầu vào, tạo một phiên bản khác của StreamDef như sau. feature_stream = StreamDef(field=’features’, shape=4, is_sparse=False)
Bước 5 − Bây giờ, khởi tạo lớp phiên bản CTFDeserializer. Chỉ định tên tệp và luồng mà chúng ta cần giải tuần tự hóa như sau − deserializer = CTFDeserializer(filename, StreamDefs(labels=label_stream, features=features_stream)
Bước 6 − Tiếp theo, chúng ta cần tạo phiên bản của minisourceBatch bằng cách sử dụng trình giải mã như sau − Minibatch_source = MinibatchSource(deserializer, randomize=True, max_sweeps=limit)return minibatch_source
Bước 7 − Cuối cùng, chúng tôi cần cung cấp nguồn đào tạo và kiểm tra mà chúng tôi đã tạo trong các phần trước. Chúng tôi đang sử dụng tập dữ liệu training_source = create_datasource(‘Iris_train.ctf’)test_source = create_datasource(‘Iris_test.ctf’, limit=1)
Sau khi bạn tạo phiên bản MinibatchSource, chúng tôi cần đào tạo phiên bản đó. Chúng ta có thể sử dụng logic huấn luyện tương tự như khi chúng ta làm việc với các tập dữ liệu nhỏ trong bộ nhớ. Ở đây, chúng ta sẽ sử dụng phiên bản MinibatchSource làm đầu vào cho phương thức huấn luyện về hàm mất mát như sau −
Sau đây là các bước triển khai−
Bước 1 − Để ghi lại kết quả của phiên đào tạo, trước tiên hãy nhập ProgressPrinter từ mô-đun cntk.logging như sau − from cntk.logging import ProgressPrinter
Bước 2 − Tiếp theo, để thiết lập phiên đào tạo, hãy nhập huấn luyện viên và như sau−cntk.traintừ mô-đun training_session from cntk.train import Trainer, training_session
Bước 3 − Bây giờ, chúng ta cần xác định một số tập hợp hằng số như minibatch_size, như sau−num_epochs và samples_per_epoch
minbatch_size = 16
samples_per_epoch = 150
num_epochs = 30
max_samples = samples_per_epoch * num_epochs
Bước 4 − Tiếp theo, để biết cách đọc dữ liệu trong quá trình đào tạo trong CNTK, chúng ta cần xác định ánh xạ giữa biến đầu vào cho mạng và các luồng trong nguồn minibatch.
input_map = {
features: training_source.streams.features,
labels: training_source.streams.labels
}
Bước 5 − Tiếp theo để ghi lại kết quả của quá trình đào tạo, hãy khởi tạo biến progress_printer với một phiên bản ProgressPrinter mới. Ngoài ra, hãy khởi tạo trainer và cung cấp cho nó mô hình như sau− progress_writer = ProgressPrinter(0)trainer: training_source.streams.labels
Bước 6 − Cuối cùng, để bắt đầu quá trình đào tạo, chúng ta cần gọi training_session hoạt động như sau
session = training_session(trainer,
mb_source=training_source,
mb_size=minibatch_size,
model_inputs_to_streams=input_map,
max_samples=max_samples,
test_config=test_config)
session.train()
Sau khi đào tạo mô hình, chúng tôi có thể thêm xác thực vào thiết lập này bằng cách sử dụng đối tượng TestConfig và gán nó cho test_config đối số từ khóa của hàm train_session.
Sau đây là các bước triển khai−
Bước 1 − Đầu tiên, chúng ta cần nhập lớp TestConfig từ mô-đun như sau−cntk.train from cntk.train import TestConfig
Bước 2 − Bây giờ, chúng ta cần tạo một phiên bản mới của TestConfig với < /span> làm đầu vào−test_source Test_config = TestConfig(test_source)
Ví dụ hoàn chỉnh :
from cntk.io import StreamDef, StreamDefs, MinibatchSource, CTFDeserializer, INFINITY_REPEAT
def create_datasource(filename, limit =INFINITELY_REPEAT)
labels_stream = StreamDef(field=’labels’, shape=3, is_sparse=False)
feature_stream = StreamDef(field=’features’, shape=4, is_sparse=False)
deserializer = CTFDeserializer(filename, StreamDefs(labels=label_stream, features=features_stream)
Minibatch_source = MinibatchSource(deserializer, randomize=True, max_sweeps=limit)
return minibatch_source
training_source = create_datasource(‘Iris_train.ctf’)
test_source = create_datasource(‘Iris_test.ctf’, limit=1)
from cntk.logging import ProgressPrinter
from cntk.train import Trainer, training_session
minbatch_size = 16
samples_per_epoch = 150
num_epochs = 30
max_samples = samples_per_epoch * num_epochs
input_map = {
features: training_source.streams.features,
labels: training_source.streams.labels
}
progress_writer = ProgressPrinter(0)
trainer: training_source.streams.labels
session = training_session(trainer,
mb_source=training_source,
mb_size=minibatch_size,
model_inputs_to_streams=input_map,
max_samples=max_samples,
test_config=test_config)
session.train()
from cntk.train import TestConfig
Test_config = TestConfig(test_source)
đầu ra :
average since average since examples
loss last metric last
------------------------------------------------------
Learning rate per minibatch: 0.1
1.57 1.57 0.214 0.214 16
1.38 1.28 0.264 0.289 48
[………]Finished Evaluation [1]: Minibatch[1-1]:metric = 69.65*30;
Vòng lặp minibatch thủ công
Như chúng ta thấy ở trên, thật dễ dàng để đo lường hiệu suất của mô hình NN của chúng ta trong và sau khi đào tạo bằng cách sử dụng các số liệu khi đào tạo với các API thông thường trong CNTK. Tuy nhiên, mặt khác, mọi thứ sẽ không dễ dàng như vậy khi làm việc với vòng lặp minibatch thủ công. Ở đây, chúng tôi đang sử dụng mô hình được đưa ra bên dưới với 4 đầu vào và 3 đầu ra từ bộ dữ liệu Iris Flower, cũng được tạo trong các phần trước
from cntk import default_options, input_variable
from cntk.layers import Dense, Sequential
from cntk.ops import log_softmax, relu, sigmoid
from cntk.learners import sgd
model = Sequential([
Dense(4, activation=sigmoid),
Dense(3, activation=log_softmax)
])
features = input_variable(4)
labels = input_variable(3)
z = model(features)
Tiếp theo, tổn thất cho mô hình được xác định là sự kết hợp giữa hàm mất entropy chéo và chỉ số đo F như được sử dụng trong các phần trước. Chúng ta sẽ sử dụng tiện ích criterion_factory để tạo đối tượng này dưới dạng đối tượng hàm CNTK như hiển thị bên dưới
import cntk
from cntk.losses import cross_entropy_with_softmax, fmeasure
@cntk.Function
def criterion_factory(outputs, targets):
loss = cross_entropy_with_softmax(outputs, targets)
metric = fmeasure(outputs, targets, beta=1)
return loss, metric
loss = criterion_factory(z, labels)
learner = sgd(z.parameters, 0.1)
label_mapping = {
'Iris-setosa': 0,
'Iris-versicolor': 1,
'Iris-virginica': 2
}
Bây giờ, khi chúng ta đã xác định hàm mất mát, chúng ta sẽ xem cách chúng ta có thể sử dụng nó trong trình huấn luyện để thiết lập một buổi đào tạo thủ công.
Sau đây là các bước thực hiện –
Bước 1 − Đầu tiên, chúng ta cần nhập các gói cần thiết như numpy và để tải và xử lý trước dữ liệu.gấu trúc
import pandas as pd
import numpy as np
Bước 2 − Tiếp theo, để ghi thông tin trong quá trình đào tạo, hãy nhập lớp ProgressPrinter dưới dạng theo sau− from cntk.logging import ProgressPrinter
Bước 3 − Sau đó, chúng ta cần nhập mô-đun huấn luyện viên từ mô-đun cntk.train như sau −
from cntk.train import Trainer
Bước 4 − Tiếp theo, tạo một phiên bản mới của ProgressPrinter như sau −
progress_writer = ProgressPrinter(0)
Bước 5 − Bây giờ, chúng ta cần khởi tạo trình huấn luyện với các tham số loss, learner và progress_writer như sau −
trainer = Trainer(z, loss, learner, progress_writer)
Bước 6 −Tiếp theo, để huấn luyện mô hình, chúng ta sẽ tạo một vòng lặp lặp lại tập dữ liệu ba mươi lần. Đây sẽ là vòng đào tạo bên ngoài. for _ in range(0,30):
Bước 7 − Bây giờ, chúng ta cần tải dữ liệu từ đĩa bằng pandas. Sau đó, để tải tập dữ liệu theo các lô nhỏ, hãy đặt chunksize đối số từ khóa thành 16.
input_data = pd.read_csv('iris.csv',
names=['sepal_length', 'sepal_width','petal_length','petal_width', 'species'],
index_col=False, chunksize=16)
Bước 8 − Bây giờ, hãy tạo một vòng lặp for đào tạo bên trong để lặp qua từng các lô nhỏ. for df_batch in input_data:
Bước 9 − Bây giờ, trong vòng lặp này, hãy đọc bốn cột đầu tiên bằng cách sử dụng bộ chỉ mục iloc , là các tính năng để đào tạo và chuyển đổi chúng thành float32 −
feature_values = df_batch.iloc[:,:4].values
feature_values = feature_values.astype(np.float32)
Bước 10 − Bây giờ, hãy đọc cột cuối cùng làm nhãn để huấn luyện, như sau − label_values = df_batch.iloc[:,-1]
Bước 11 − Tiếp theo, chúng ta sẽ sử dụng vectơ one-hot để chuyển đổi chuỗi nhãn sang dạng số như sau − label_values = label_values.map(lambda x: label_mapping[x])
Bước 12 − Sau đó, hãy trình bày các nhãn bằng số. Tiếp theo, chuyển đổi chúng thành một mảng có nhiều mảng để làm việc với chúng dễ dàng hơn như sau − label_values = label_values.values
Bước 13 − Bây giờ, chúng ta cần tạo một mảng có nhiều mảng mới có cùng số hàng với các giá trị nhãn mà chúng ta đã chuyển đổi. encoded_labels = np.zeros((label_values.shape[0], 3))
Bước 14 − Bây giờ, để tạo các nhãn được mã hóa một lần, hãy chọn các cột dựa trên các giá trị nhãn số. encoded_labels[np.arange(label_values.shape[0]), label_values] = 1.
Bước 15 − Cuối cùng, chúng ta cần gọi phương thức train_minibatch trên trình huấn luyện và cung cấp các tính năng và nhãn đã được xử lý cho lô nhỏ. trainer.train_minibatch({features: feature_values, labels: encoded_labels})
Ví dụ hoàn chỉnh
from cntk import default_options, input_variable
from cntk.layers import Dense, Sequential
from cntk.ops import log_softmax, relu, sigmoid
from cntk.learners import sgd
model = Sequential([
Dense(4, activation=sigmoid),
Dense(3, activation=log_softmax)
])
features = input_variable(4)
labels = input_variable(3)
z = model(features)
import cntk
from cntk.losses import cross_entropy_with_softmax, fmeasure
@cntk.Function
def criterion_factory(outputs, targets):
loss = cross_entropy_with_softmax(outputs, targets)
metric = fmeasure(outputs, targets, beta=1)
return loss, metric
loss = criterion_factory(z, labels)
learner = sgd(z.parameters, 0.1)
label_mapping = {
'Iris-setosa': 0,
'Iris-versicolor': 1,
'Iris-virginica': 2
}
import pandas as pd
import numpy as np
from cntk.logging import ProgressPrinter
from cntk.train import Trainer
progress_writer = ProgressPrinter(0)
trainer = Trainer(z, loss, learner, progress_writer)
for _ in range(0,30):
input_data = pd.read_csv('iris.csv',
names=['sepal_length', 'sepal_width','petal_length','petal_width', 'species'],
index_col=False, chunksize=16)
for df_batch in input_data:
feature_values = df_batch.iloc[:,:4].values
feature_values = feature_values.astype(np.float32)
label_values = df_batch.iloc[:,-1]
label_values = label_values.map(lambda x: label_mapping[x])
label_values = label_values.values
encoded_labels = np.zeros((label_values.shape[0], 3))
encoded_labels[np.arange(label_values.shape[0]),
label_values] = 1.
trainer.train_minibatch({features: feature_values, labels: encoded_labels})
đầu ra:
-------------------------------------------------------------------
average since average since examples
loss last metric last
------------------------------------------------------
Learning rate per minibatch: 0.1
1.45 1.45 -0.189 -0.189 16
1.24 1.13 -0.0382 0.0371 48
[………]
Trong kết quả đầu ra ở trên, chúng tôi nhận được cả đầu ra về tổn thất và số liệu trong quá trình đào tạo. Đó là do chúng tôi đã kết hợp số liệu và mất mát trong một đối tượng hàm và sử dụng máy in tiến trình trong cấu hình huấn luyện viên.
Bây giờ, để đánh giá hiệu suất của mô hình, chúng ta cần thực hiện nhiệm vụ tương tự như khi đào tạo mô hình, nhưng lần này, chúng ta cần sử dụng Trình đánh giá để kiểm tra mô hình. Nó được hiển thị trong mã Python sau đây−
from cntk import Evaluator
evaluator = Evaluator(loss.outputs[1], [progress_writer])
input_data = pd.read_csv('iris.csv',
names=['sepal_length', 'sepal_width','petal_length','petal_width', 'species'],
index_col=False, chunksize=16)
for df_batch in input_data:
feature_values = df_batch.iloc[:,:4].values
feature_values = feature_values.astype(np.float32)
label_values = df_batch.iloc[:,-1]
label_values = label_values.map(lambda x: label_mapping[x])
label_values = label_values.values
encoded_labels = np.zeros((label_values.shape[0], 3))
encoded_labels[np.arange(label_values.shape[0]), label_values] = 1.
evaluator.test_minibatch({ features: feature_values, labels:
encoded_labels})
evaluator.summarize_test_progress()
Bây giờ, chúng ta sẽ nhận được kết quả đầu ra như sau:
đầu ra : Finished Evaluation [1]: Minibatch[1-11]:metric = 74.62*143;
Xem thêm : CNTK – Giám sát mô hình