CNTK

Cơ bản về xác nhận mô hình hồi quy

Như chúng ta biết rằng các mô hình hồi quy khác với các mô hình phân loại, theo nghĩa là không có thước đo nhị phân nào về đúng hay sai đối với mẫu của từng cá nhân. Trong các mô hình hồi quy, chúng ta muốn đo lường mức độ gần của dự đoán với giá trị thực tế. Giá trị dự đoán càng gần với đầu ra dự kiến ​​thì mô hình càng hoạt động tốt hơn.

Ở đây, chúng ta sẽ đo hiệu suất của NN được sử dụng để hồi quy bằng các hàm tỷ lệ lỗi khác nhau.

Tính toán biên độ sai số

Như đã thảo luận trước đó, trong khi xác thực mô hình hồi quy, chúng ta không thể nói liệu dự đoán là đúng hay sai. Chúng tôi muốn dự đoán của mình càng gần với giá trị thực càng tốt. Tuy nhiên, ở đây có thể chấp nhận được một mức sai số nhỏ. Công thức tính biên độ sai số như sau

Đây, Giá trị dự đoán = được biểu thị bằng y bằng mũ

Giá trị thực = được dự đoán bởi y

Đầu tiên, chúng ta cần tính khoảng cách giữa giá trị dự đoán và giá trị thực. Sau đó, để có được tỷ lệ lỗi tổng thể, chúng ta cần tính tổng các khoảng cách bình phương này và tính giá trị trung bình. Đây được gọi là hàm lỗi bình phương trung bình. Tuy nhiên, nếu chúng ta muốn số liệu hiệu suất biểu thị mức sai số, chúng ta cần một công thức biểu thị sai số tuyệt đối. Công thức cho hàm lỗi trung bình tuyệt đối như sau

Công thức trên lấy khoảng cách tuyệt đối giữa giá trị dự đoán và giá trị thực.

Sử dụng CNTK để đo hiệu suất hồi quy

Ở đây, chúng ta sẽ xem xét cách sử dụng các số liệu khác nhau mà chúng ta đã thảo luận khi kết hợp với CNTK. Chúng tôi sẽ sử dụng mô hình hồi quy để dự đoán số dặm trên mỗi gallon cho ô tô bằng cách sử dụng các bước dưới đây.

Các bước thực hiện−

Bước 1 − Đầu tiên, chúng ta cần nhập các thành phần cần thiết từ gói cntk như sau − from cntk import default_option, input_variablefrom cntk.layers import Dense, Sequentialfrom cntk.ops import relu

Bước 2 − Tiếp theo, chúng ta cần xác định hàm kích hoạt mặc định bằng cách sử dụng các hàm default_options. Sau đó, tạo một bộ lớp Tuần tự mới và cung cấp hai lớp Dày đặc với 64 nơ-ron mỗi lớp. Sau đó, chúng ta thêm một lớp Mật độ bổ sung (sẽ đóng vai trò là lớp đầu ra) vào tập hợp lớp Tuần tự và cung cấp 1 nơ-ron mà không cần kích hoạt như sau − with default_options(activation=relu):model = Sequential([Dense(64),Dense(64),Dense(1,activation=None)])

Bước 3 − Khi mạng đã được tạo, chúng ta cần tạo một tính năng đầu vào. Chúng ta cần đảm bảo rằng nó có hình dạng giống với các tính năng mà chúng ta sẽ sử dụng để đào tạo. features = input_variable(X.shape[1])

Bước 4 − Bây giờ, chúng ta cần tạo một input_variable khác với kích thước 1. Nó sẽ là được sử dụng để lưu trữ giá trị mong đợi cho NN. target = input_variable(1)z = model(features)

Bây giờ, chúng ta cần huấn luyện mô hình và để làm như vậy, chúng ta sẽ chia tập dữ liệu và thực hiện tiền xử lý bằng các bước triển khai sau –

Bước 5 −Đầu tiên, nhập StandardScaler từ sklearn.preprocessing để nhận các giá trị từ -1 đến +1. Điều này sẽ giúp chúng tôi chống lại các vấn đề bùng nổ về độ dốc trong NN. from sklearn.preprocessing import StandardScalar

Bước 6 − Tiếp theo, nhập train_test_split từ sklearn.model_selection như sau− from sklearn.model_selection import train_test_split

Bước 7 − Bỏ cột mpg khỏi tập dữ liệu bằng cách sử dụng < một phương thức i=4>thả. Cuối cùng, chia tập dữ liệu thành tập huấn luyện và xác thực bằng cách sử dụng hàm train_test_split như sau

x = df_cars.drop(columns=[‘mpg’]).values.astype(np.float32)
y=df_cars.iloc[: , 0].values.reshape(-1, 1).astype(np.float32)
scaler = StandardScaler()
X = scaler.fit_transform(x)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

Bước 8 − Bây giờ, chúng ta cần tạo một input_variable khác có kích thước 1. Nó sẽ được sử dụng để lưu trữ giá trị mong đợi cho NN. target = input_variable(1)z = model(features)Chúng ta đã phân tách cũng như xử lý trước dữ liệu, bây giờ chúng ta cần huấn luyện NN. Như đã làm trong các phần trước khi tạo mô hình hồi quy, chúng ta cần xác định sự kết hợp giữa hàm loss và metric để huấn luyện mô hình.

import cntk
def absolute_error(output, target):
   return cntk.ops.reduce_mean(cntk.ops.abs(output – target))
@ cntk.Function
def criterion_factory(output, target):
   loss = squared_error(output, target)
   metric = absolute_error(output, target)
   return loss, metric

Bây giờ, chúng ta hãy xem cách sử dụng mô hình đã được đào tạo. Đối với mô hình của chúng tôi, chúng tôi sẽ sử dụng Criteria_factory làm kết hợp tổn thất và số liệu.

from cntk.losses import squared_error
from cntk.learners import sgd
from cntk.logging import ProgressPrinter
progress_printer = ProgressPrinter(0)
loss = criterion_factory (z, target)
learner = sgd(z.parameters, 0.001)
training_summary=loss.train((x_train,y_train),parameter_learners=[learner],callbacks=[progress_printer],minibatch_size=16,max_epochs=10)

Ví dụ triển khai hoàn chỉnh

from cntk import default_option, input_variable
from cntk.layers import Dense, Sequential
from cntk.ops import relu
with default_options(activation=relu):
model = Sequential([Dense(64),Dense(64),Dense(1,activation=None)])
features = input_variable(X.shape[1])
target = input_variable(1)
z = model(features)
from sklearn.preprocessing import StandardScalar
from sklearn.model_selection import train_test_split
x = df_cars.drop(columns=[‘mpg’]).values.astype(np.float32)
y=df_cars.iloc[: , 0].values.reshape(-1, 1).astype(np.float32)
scaler = StandardScaler()
X = scaler.fit_transform(x)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
target = input_variable(1)
z = model(features)
import cntk
def absolute_error(output, target):
   return cntk.ops.reduce_mean(cntk.ops.abs(output – target))
@ cntk.Function
def criterion_factory(output, target):
loss = squared_error(output, target)
metric = absolute_error(output, target)
return loss, metric
from cntk.losses import squared_error
from cntk.learners import sgd
from cntk.logging import ProgressPrinter
progress_printer = ProgressPrinter(0)
loss = criterion_factory (z, target)
learner = sgd(z.parameters, 0.001)
training_summary=loss.train((x_train,y_train),parameter_learners=[learner],callbacks=[progress_printer],minibatch_size=16,max_epochs=10)

đầu ra:

average  since   average   since  examples
loss     last    metric    last
------------------------------------------------------
Learning rate per minibatch: 0.001
690       690     24.9     24.9       16
654       636     24.1     23.7       48
[………]

Để xác thực mô hình hồi quy của chúng tôi, chúng tôi cần đảm bảo rằng mô hình xử lý dữ liệu mới giống như với dữ liệu huấn luyện. Để làm điều này, chúng ta cần gọi phương thức test trên loss và < /span> kết hợp với dữ liệu thử nghiệm như sau −metric loss.test([X_test, y_test]) Đầu ra: 

{'metric': 1.89679785619, 'samples': 79}

Xem thêm : CNTK – Bộ dữ liệu hết bộ nhớ

Trả lời