Hướng dẫn Cách Thiết lập Microsoft SharePoint Chi Tiết

The post Sharepoint Site có các công năng gì cho doanh nghiệp appeared first on Dongthoigian.

1. Họp trực tuyến với 500 người cùng một lúc miễn phí:

Microsoft Teams cho phép bạn tổ chức cuộc họp trực tuyến với đến 500 người một cách dễ dàng.

2. Điều phối kế hoạch trong nhóm của bạn một cách dễ dàng:

Bạn có thể tạo, xem lịch biểu và tham gia cuộc họp của mình một cách tiện lợi.

3. Trò chuyện trực tuyến với một hoặc nhiều người nhanh, đơn giản:

Microsoft Teams cho phép bạn giao tiếp qua tin nhắn văn bản hoặc cuộc gọi thoại với đồng nghiệp.

4 Chia sẻ thông qua các tệp đơn giản, nhanh tiết kiệm thời gian:

Bạn có thể chia sẻ tài liệu, hình ảnh, video và tệp khác một cách dễ dàng.

5 Khả năng tích hợp cao:

Microsoft Teams tích hợp với hơn 300 ứng dụng dành cho công việc. Bạn cũng có thể tích hợp các ứng dụng bên ngoài và sử dụng lịch hoạt ngay trong Teams.

6 Đồng bộ tác giả trong tập tin dùng chung:

Với các tài liệu dùng chung như Word, Excel, Microsoft 365 cho phép người dùng công tác trực tuyến và xem lại lịch sử chỉnh sửa, thay đổi của mọi thành viên.

7 Lưu trữ tài nguyên SharePoint:

Khi bạn sử dụng Microsoft Teams, hệ thống tự động hỗ trợ một trang SharePoint Online cho mỗi nhóm. Đây là nơi lưu trữ các tài liệu mặc định của mỗi nhóm.

8 Tạo hội nghị âm thanh:

Microsoft Teams cho phép bạn tổ chức hội nghị âm thanh với đồng nghiệp một cách thuận tiện.

Xem Cách Thiết Lập Microsoft Teams :

The post Ứng dụng Microsoft Teams có các chức năng gì nổi bật appeared first on Dongthoigian.

Chúng tôi đã học cách phân loại hình ảnh bằng mạng lưới thần kinh và đó là một trong những công việc mang tính biểu tượng trong học sâu. Tuy nhiên, một lĩnh vực khác mà mạng thần kinh vượt trội và có nhiều nghiên cứu đang diễn ra là Mạng thần kinh tái phát (RNN). Ở đây, chúng ta sẽ biết RNN là gì và làm thế nào nó có thể được sử dụng trong các tình huống mà chúng ta cần xử lý dữ liệu chuỗi thời gian.

Mạng thần kinh tái phát là gì?

Mạng thần kinh tái phát (RNN) có thể được định nghĩa là loại NN đặc biệt có khả năng suy luận theo thời gian. RNN chủ yếu được sử dụng trong các tình huống, trong đó chúng ta cần xử lý các giá trị thay đổi theo thời gian, tức là dữ liệu chuỗi thời gian. Để hiểu nó theo cách tốt hơn, chúng ta hãy so sánh nhỏ giữa mạng nơ-ron thông thường và mạng nơ-ron tái phát –

• Như chúng ta biết rằng, trong mạng nơ-ron thông thường, chúng ta chỉ có thể cung cấp một đầu vào. Điều này giới hạn nó chỉ dẫn đến một dự đoán. Để cho bạn một ví dụ, chúng tôi có thể thực hiện công việc dịch văn bản bằng cách sử dụng mạng nơ-ron thông thường.
• Mặt khác, trong các mạng thần kinh tái diễn, chúng ta có thể cung cấp một chuỗi mẫu dẫn đến một dự đoán duy nhất. Nói cách khác, sử dụng RNN, chúng ta có thể dự đoán chuỗi đầu ra dựa trên chuỗi đầu vào. Ví dụ, đã có khá nhiều thử nghiệm thành công với RNN trong các tác vụ dịch thuật.

Công dụng của mạng thần kinh tái phát

RNN có thể được sử dụng theo nhiều cách. Một số trong số chúng như sau –

Dự đoán một đầu ra duy nhất

Trước khi đi sâu vào các bước, cách RNN có thể dự đoán một đầu ra dựa trên một chuỗi, hãy xem RNN cơ bản trông như thế nào

Như chúng ta có thể làm trong sơ đồ trên, RNN chứa kết nối vòng lặp tới đầu vào và bất cứ khi nào chúng ta cung cấp một chuỗi các giá trị, nó sẽ xử lý từng phần tử trong chuỗi theo các bước thời gian.

Hơn nữa, nhờ kết nối vòng lặp, RNN có thể kết hợp đầu ra được tạo với đầu vào cho phần tử tiếp theo trong chuỗi. Bằng cách này, RNN sẽ xây dựng bộ nhớ trên toàn bộ chuỗi có thể được sử dụng để đưa ra dự đoán.

Để đưa ra dự đoán với RNN, chúng ta có thể thực hiện các bước sau−

• Đầu tiên, để tạo trạng thái ẩn ban đầu, chúng ta cần cung cấp phần tử đầu tiên của chuỗi đầu vào.
• Sau đó, để tạo trạng thái ẩn cập nhật, chúng ta cần lấy trạng thái ẩn ban đầu và kết hợp nó với phần tử thứ hai trong chuỗi đầu vào.
• Cuối cùng, để tạo trạng thái ẩn cuối cùng và dự đoán đầu ra cho RNN, chúng ta cần lấy phần tử cuối cùng trong chuỗi đầu vào.

Bằng cách này, với sự trợ giúp của kết nối vòng lặp này, chúng ta có thể dạy RNN nhận biết các mẫu xảy ra theo thời gian.

Dự đoán trình tự

Mô hình cơ bản, đã thảo luận ở trên, của RNN cũng có thể được mở rộng sang các trường hợp sử dụng khác. Ví dụ: chúng ta có thể sử dụng nó để dự đoán một chuỗi giá trị dựa trên một đầu vào duy nhất. Trong trường hợp này, để đưa ra dự đoán với RNN, chúng ta có thể thực hiện các bước sau –

• Đầu tiên, để tạo trạng thái ẩn ban đầu và dự đoán phần tử đầu tiên trong chuỗi đầu ra, chúng ta cần đưa mẫu đầu vào vào mạng nơ-ron.
• Sau đó, để tạo trạng thái ẩn được cập nhật và phần tử thứ hai trong chuỗi đầu ra, chúng ta cần kết hợp trạng thái ẩn ban đầu với cùng một mẫu.
• Cuối cùng, để cập nhật trạng thái ẩn một lần nữa và dự đoán phần tử cuối cùng trong chuỗi đầu ra, chúng tôi nạp mẫu vào một lần khác.

Dự đoán trình tự

Như chúng ta đã thấy cách dự đoán một giá trị dựa trên một chuỗi và cách dự đoán một chuỗi dựa trên một giá trị. Bây giờ hãy xem cách chúng ta có thể dự đoán trình tự cho các trình tự. Trong trường hợp này, để đưa ra dự đoán với RNN, chúng ta có thể thực hiện các bước sau –

• Đầu tiên, để tạo trạng thái ẩn ban đầu và dự đoán phần tử đầu tiên trong chuỗi đầu ra, chúng ta cần lấy phần tử đầu tiên trong chuỗi đầu vào.
• Sau đó, để cập nhật trạng thái ẩn và dự đoán phần tử thứ hai trong chuỗi đầu ra, chúng ta cần lấy trạng thái ẩn ban đầu.
• Cuối cùng, để dự đoán phần tử cuối cùng trong chuỗi đầu ra, chúng ta cần lấy trạng thái ẩn được cập nhật và phần tử cuối cùng trong chuỗi đầu vào.

Hoạt động của RNN

Để hiểu hoạt động của mạng thần kinh tái phát (RNN), trước tiên chúng ta cần hiểu cách hoạt động của các lớp tái phát trong mạng. Vì vậy, trước tiên hãy thảo luận về cách e có thể dự đoán đầu ra bằng lớp lặp lại tiêu chuẩn.

Dự đoán đầu ra với lớp RNN tiêu chuẩn

Như chúng ta đã thảo luận trước đó, lớp cơ bản trong RNN khá khác với lớp thông thường trong mạng nơ-ron. Trong phần trước, chúng tôi cũng đã trình bày trên sơ đồ kiến ​​trúc cơ bản của RNN. Để cập nhật trạng thái ẩn cho trình tự bước vào lần đầu tiên, chúng ta có thể sử dụng công thức sau

Trong phương trình trên, chúng ta tính toán trạng thái ẩn mới bằng cách tính tích số chấm giữa trạng thái ẩn ban đầu và một tập hợp trọng số.

Bây giờ đối với bước tiếp theo, trạng thái ẩn cho bước thời gian hiện tại được sử dụng làm trạng thái ẩn ban đầu cho bước thời gian tiếp theo trong chuỗi. Đó là lý do tại sao, để cập nhật trạng thái ẩn cho bước lần thứ hai, chúng ta có thể lặp lại các phép tính được thực hiện ở bước lần đầu tiên như sau –

Tiếp theo, chúng ta có thể lặp lại quá trình cập nhật trạng thái ẩn cho bước thứ ba và bước cuối cùng trong trình tự như dưới đây –

Và khi chúng ta đã xử lý tất cả các bước trên theo trình tự, chúng ta có thể tính toán kết quả đầu ra như sau –

Đối với công thức trên, chúng tôi đã sử dụng bộ trọng số thứ ba và trạng thái ẩn từ bước thời gian cuối cùng.

Đơn vị định kỳ nâng cao

Vấn đề chính với lớp hồi quy cơ bản là vấn đề biến mất độ dốc và do đó, nó không tốt trong việc tìm hiểu các mối tương quan dài hạn. Nói một cách đơn giản, lớp lặp lại cơ bản không xử lý tốt các chuỗi dài. Đó là lý do tại sao một số loại lớp lặp lại khác phù hợp hơn nhiều để làm việc với các chuỗi dài hơn như sau:

Trí nhớ ngắn hạn dài hạn (LSTM)

Mạng bộ nhớ dài hạn (LSTM) được giới thiệu bởi Hochreiter & Schmidhuber. Nó giải quyết được vấn đề có được một lớp lặp lại cơ bản để ghi nhớ mọi thứ trong một thời gian dài. Kiến trúc của LSTM được đưa ra ở sơ đồ trên. Như chúng ta có thể thấy, nó có các nơ-ron đầu vào, các ô nhớ và các nơ-ron đầu ra. Để giải quyết vấn đề độ dốc biến mất, mạng bộ nhớ ngắn hạn dài sử dụng một ô nhớ rõ ràng (lưu trữ các giá trị trước đó) và các cổng sau –

• Quên cổng− Đúng như tên gọi, nó báo cho ô nhớ quên các giá trị trước đó. Ô nhớ lưu trữ các giá trị cho đến khi cổng, tức là ‘quên cổng’ yêu cầu nó quên chúng.
• Cổng đầu vào− Đúng như tên gọi, nó thêm nội dung mới vào ô.
• Cổng đầu ra− Như tên ngụ ý, cổng đầu ra quyết định thời điểm chuyển dọc theo các vectơ từ ô sang trạng thái ẩn tiếp theo.

Đơn vị định kỳ có kiểm soát (GRU)

Đơn vị lặp lại theo độ dốc (GRU) là một biến thể nhỏ của mạng LSTM. Nó có ít cổng hơn và có dây hơi khác so với LSTM. Kiến trúc của nó được thể hiện trong sơ đồ trên. Nó có các nơ-ron đầu vào, các ô nhớ có cổng và các nơ-ron đầu ra. Mạng Đơn vị định kỳ có cổng có hai cổng sau −

• Cổng cập nhật− Nó xác định hai điều sau đây−
  • Lượng thông tin nào nên được giữ lại từ trạng thái cuối cùng?
  • Lượng thông tin nào sẽ được đưa vào từ lớp trước?
• Cổng đặt lại− Chức năng của cổng đặt lại rất giống với cổng quên của mạng LSTM. Sự khác biệt duy nhất là nó nằm ở vị trí hơi khác một chút.

Ngược lại với mạng bộ nhớ dài hạn, mạng Đơn vị định kỳ có cổng nhanh hơn và dễ chạy hơn một chút.

Tạo cấu trúc RNN

Trước khi có thể bắt đầu đưa ra dự đoán về đầu ra từ bất kỳ nguồn dữ liệu nào, trước tiên chúng ta cần xây dựng RNN và việc xây dựng RNN khá giống với cách chúng ta đã xây dựng mạng nơ-ron thông thường trong phần trước. Sau đây là mã để xây dựng một−

Đơn vị lặp lại theo độ dốc (GRU) là một biến thể nhỏ của mạng LSTM. Nó có ít cổng hơn và có dây hơi khác so với LSTM. Kiến trúc của nó được thể hiện trong sơ đồ trên. Nó có các nơ-ron đầu vào, các ô nhớ có cổng và các nơ-ron đầu ra. Mạng Đơn vị định kỳ có cổng có hai cổng sau −
•	Cổng cập nhật− Nó xác định hai điều sau đây−
o	Lượng thông tin nào nên được giữ lại từ trạng thái cuối cùng?
o	Lượng thông tin nào sẽ được đưa vào từ lớp trước?
•	Cổng đặt lại− Chức năng của cổng đặt lại rất giống với cổng quên của mạng LSTM. Sự khác biệt duy nhất là nó nằm ở vị trí hơi khác một chút.
Ngược lại với mạng bộ nhớ dài hạn, mạng Đơn vị định kỳ có cổng nhanh hơn và dễ chạy hơn một chút.
Tạo cấu trúc RNN
Trước khi có thể bắt đầu đưa ra dự đoán về đầu ra từ bất kỳ nguồn dữ liệu nào, trước tiên chúng ta cần xây dựng RNN và việc xây dựng RNN khá giống với cách chúng ta đã xây dựng mạng nơ-ron thông thường trong phần trước. Sau đây là mã để xây dựng một−
from cntk.losses import squared_error
from cntk.io import CTFDeserializer, MinibatchSource, INFINITELY_REPEAT, StreamDefs, StreamDef
from cntk.learners import adam
from cntk.logging import ProgressPrinter
from cntk.train import TestConfig
BATCH_SIZE = 14 * 10
EPOCH_SIZE = 12434
EPOCHS = 10

Đặt cược nhiều lớp

Chúng tôi cũng có thể xếp chồng nhiều lớp lặp lại trong CNTK. Ví dụ: chúng ta có thể sử dụng tổ hợp các lớp sau đây−

from cntk import sequence, default_options, input_variable
from cntk.layers import Recurrence, LSTM, Dropout, Dense, Sequential, Fold
features = sequence.input_variable(1)
with default_options(initial_state = 0.1):
   model = Sequential([
      Fold(LSTM(15)),
      Dense(1)
   ])(features)
target = input_variable(1, dynamic_axes=model.dynamic_axes)

Như chúng ta có thể thấy trong đoạn mã trên, chúng ta có hai cách sau để có thể lập mô hình RNN trong CNTK –

• Đầu tiên, nếu chúng ta chỉ muốn đầu ra cuối cùng của lớp lặp lại, chúng ta có thể sử dụng lớp Fold kết hợp với lớp lặp lại, chẳng hạn như GRU, LSTM hoặc thậm chí RNNStep.
• Thứ hai, như một cách khác, chúng ta cũng có thể sử dụng khối Recurrence.

Huấn luyện RNN với dữ liệu chuỗi thời gian

Sau khi xây dựng mô hình, hãy xem cách chúng tôi có thể huấn luyện RNN trong CNTK

from cntk import Function
@Function
def criterion_factory(z, t):
   loss = squared_error(z, t)
   metric = squared_error(z, t)
   return loss, metric
loss = criterion_factory(model, target)
learner = adam(model.parameters, lr=0.005, momentum=0.9)

Bây giờ để tải dữ liệu vào quá trình huấn luyện, chúng ta phải giải tuần tự hóa các chuỗi từ một tập hợp tệp CTF. Mã sau có hàm create_datasource, đây là một hàm tiện ích hữu ích để tạo cả nguồn dữ liệu huấn luyện và kiểm tra.

target_stream = StreamDef(field='target', shape=1, is_sparse=False)
features_stream = StreamDef(field='features', shape=1, is_sparse=False)
deserializer = CTFDeserializer(filename, StreamDefs(features=features_stream, target=target_stream))
   datasource = MinibatchSource(deserializer, randomize=True, max_sweeps=sweeps)
return datasource
train_datasource = create_datasource('Training data filename.ctf')#we need to provide the location of training file we created from our dataset.
test_datasource = create_datasource('Test filename.ctf', sweeps=1) #we need to provide the location of testing file we created from our dataset.

Bây giờ, khi chúng ta đã thiết lập nguồn dữ liệu, mô hình và hàm mất dữ liệu, chúng ta có thể bắt đầu quá trình đào tạo. Nó khá giống với những gì chúng ta đã làm trong các phần trước với mạng nơ-ron cơ bản.

progress_writer = ProgressPrinter(0)
test_config = TestConfig(test_datasource)
input_map = {
   features: train_datasource.streams.features,
   target: train_datasource.streams.target
}
history = loss.train(
   train_datasource,
   epoch_size=EPOCH_SIZE,
   parameter_learners=[learner],
   model_inputs_to_streams=input_map,
   callbacks=[progress_writer, test_config],
   minibatch_size=BATCH_SIZE,
   max_epochs=EPOCHS
)

Chúng ta sẽ nhận được kết quả tương tự như sau –

Đầu ra−

average  since  average  since  examples
loss      last  metric  last
------------------------------------------------------
Learning rate per minibatch: 0.005
0.4      0.4    0.4      0.4      19
0.4      0.4    0.4      0.4      59
0.452    0.495  0.452    0.495   129
[…]

Xác thực mô hình

Trên thực tế, việc đọc lại bằng RNN khá giống với việc đưa ra dự đoán với bất kỳ mô hình CNK nào khác. Sự khác biệt duy nhất là chúng tôi cần cung cấp trình tự thay vì các mẫu đơn lẻ. Bây giờ, vì RNN của chúng ta cuối cùng đã hoàn tất quá trình đào tạo, chúng ta có thể xác thực mô hình bằng cách kiểm tra nó bằng cách sử dụng một vài chuỗi mẫu như sau –

import pickle
with open('test_samples.pkl', 'rb') as test_file:
test_samples = pickle.load(test_file)
model(test_samples) * NORMALIZE

Đầu ra−

array([[ 8081.7905],
[16597.693 ],
[13335.17 ],
...,
[11275.804 ],
[15621.697 ],
[16875.555 ]], dtype=float32)

The post CNTK – Mạng thần kinh tái phát appeared first on Dongthoigian.

Mạng nơ-ron tích chập (CNN) cũng được tạo thành từ các nơ-ron, có trọng số và độ lệch có thể học được. Đó là lý do tại sao theo cách này, chúng giống như các mạng thần kinh (NN) thông thường.

Nếu chúng ta nhớ lại hoạt động của các NN thông thường, mỗi nơ-ron sẽ nhận được một hoặc nhiều đầu vào, lấy một tổng có trọng số và chuyển qua hàm kích hoạt để tạo ra đầu ra cuối cùng. Ở đây, câu hỏi đặt ra là nếu CNN và NN thông thường có nhiều điểm tương đồng như vậy thì điều gì khiến hai mạng này khác nhau?

Điều gì làm cho chúng khác biệt là việc xử lý dữ liệu đầu vào và các loại lớp? Cấu trúc của dữ liệu đầu vào bị bỏ qua trong NN thông thường và tất cả dữ liệu được chuyển đổi thành mảng 1-D trước khi đưa vào mạng.

Tuy nhiên, kiến ​​trúc Mạng thần kinh chuyển đổi có thể xem xét cấu trúc 2D của hình ảnh, xử lý chúng và cho phép nó trích xuất các thuộc tính dành riêng cho hình ảnh. Hơn nữa, CNN có lợi thế là có một hoặc nhiều lớp Convolutional và lớp gộp, là những khối xây dựng chính của CNN.

Các lớp này được theo sau bởi một hoặc nhiều lớp được kết nối đầy đủ như trong NN nhiều lớp tiêu chuẩn. Vì vậy, chúng ta có thể coi CNN là một trường hợp đặc biệt của các mạng được kết nối đầy đủ.

Kiến trúc Mạng thần kinh chuyển đổi (CNN)

Kiến trúc của CNN về cơ bản là một danh sách các lớp biến đổi khối lượng hình ảnh 3 chiều, tức là chiều rộng, chiều cao và chiều sâu thành khối lượng đầu ra 3 chiều. Một điểm quan trọng cần lưu ý ở đây là mọi nơ-ron trong lớp hiện tại được kết nối với một mảng nhỏ đầu ra từ lớp trước, giống như phủ một N*N lọc trên hình ảnh đầu vào.

Nó sử dụng M bộ lọc, về cơ bản là các công cụ trích xuất tính năng trích xuất các tính năng như cạnh, góc, v.v. Sau đây là các lớp [INPUT-CONV-RELU-POOL-FC] được sử dụng để xây dựng Mạng nơ-ron tích chập (CNN)−

• INPUT− Đúng như tên gọi, lớp này chứa các giá trị pixel thô. Giá trị pixel thô có nghĩa là dữ liệu của hình ảnh. Ví dụ: INPUT [64×64×3] là hình ảnh RGB 3 kênh có chiều rộng 64, chiều cao 64 và chiều sâu 3.
• CONV− Lớp này là một trong những khối xây dựng của CNN vì hầu hết tính toán được thực hiện trong lớp này. Ví dụ – nếu chúng tôi sử dụng 6 bộ lọc trên INPUT [64×64×3] được đề cập ở trên, điều này có thể dẫn đến âm lượng [64×64×6].
• RELU−Còn được gọi là lớp đơn vị tuyến tính được chỉnh lưu, áp dụng hàm kích hoạt cho đầu ra của lớp trước. Theo cách khác, tính phi tuyến tính sẽ được RELU thêm vào mạng.
• POOL− Lớp này, tức là lớp gộp là một khối xây dựng khác của CNN. Nhiệm vụ chính của lớp này là lấy mẫu xuống, nghĩa là nó hoạt động độc lập trên mọi lát cắt của đầu vào và thay đổi kích thước theo không gian.
• FC− Nó được gọi là Lớp được kết nối đầy đủ hay cụ thể hơn là lớp đầu ra. Nó được sử dụng để tính điểm của lớp đầu ra và kết quả đầu ra là khối lượng có kích thước 1*1*L trong đó L là số tương ứng với điểm lớp.

Sơ đồ bên dưới thể hiện kiến ​​trúc điển hình của CNN

Tạo cấu trúc CNN

Chúng ta đã thấy kiến ​​trúc và những điều cơ bản của CNN, bây giờ chúng ta sẽ xây dựng mạng tích chập bằng CNTK. Ở đây, trước tiên chúng ta sẽ xem cách kết hợp cấu trúc của CNN và sau đó chúng ta sẽ xem cách huấn luyện các tham số của nó.

Cuối cùng, chúng ta sẽ thấy cách chúng ta có thể cải thiện mạng lưới thần kinh bằng cách thay đổi cấu trúc của nó bằng nhiều cách thiết lập lớp khác nhau. Chúng tôi sẽ sử dụng tập dữ liệu hình ảnh MNIST.

Vì vậy, trước tiên hãy tạo cấu trúc CNN. Nói chung, khi chúng tôi xây dựng CNN để nhận dạng các mẫu trong hình ảnh, chúng tôi thực hiện như sau−

• Chúng tôi sử dụng kết hợp các lớp tích chập và gộp.
• Một hoặc nhiều lớp ẩn ở cuối mạng.
• Cuối cùng, chúng tôi hoàn thiện mạng bằng lớp softmax cho mục đích phân loại.

Với sự trợ giúp của các bước sau, chúng ta có thể xây dựng cấu trúc mạng−

Bước 1− Đầu tiên, chúng ta cần nhập các lớp cần thiết cho CNN. from cntk.layers import Convolution2D, Sequential, Dense, MaxPooling

Bước 2− Tiếp theo, chúng ta cần nhập các hàm kích hoạt cho CNN. from cntk.ops import log_softmax, relu

Bước 3− Sau đó để khởi tạo các lớp chập sau này, chúng ta cần nhập glorot_uniform_initializer như sau− from cntk.initializer import glorot_uniform

Bước 4− Tiếp theo, để tạo biến đầu vào, hãy nhập hàm input_variable. Và nhập hàm default_option để cấu hình NN dễ dàng hơn một chút. from cntk import input_variable, default_options

Bước 5− Bây giờ để lưu trữ hình ảnh đầu vào, hãy tạo một input_variable mới. Nó sẽ chứa ba kênh là đỏ, xanh lá cây và xanh lam. Nó sẽ có kích thước 28 x 28 pixel. features = input_variable((3,28,28))

Bước 6−Tiếp theo, chúng ta cần tạo một input_variable khác để lưu trữ các nhãn để dự đoán. labels = input_variable(10)

Bước 7− Bây giờ, chúng ta cần tạo default_option cho NN. Và chúng ta cần sử dụng glorot_uniform làm hàm khởi tạo. with default_options(initialization=glorot_uniform, activation=relu):

Bước 8− Tiếp theo, để thiết lập cấu trúc của NN, chúng ta cần tạo một Tuần tự mới< một tập hợp lớp i=3>.

Bước 9− Bây giờ chúng ta cần thêm lớp Convolutional2D với < cài đặt i=4>filter_shape trên 5 và cài đặt sải bước của 1< /span>. Ngoài ra, hãy bật phần đệm để hình ảnh được đệm để giữ nguyên kích thước ban đầu.Tuần tự, trong tập hợp lớp model = Sequential([Convolution2D(filter_shape=(5,5), strides=(1,1), num_filters=8, pad=True),

Bước 10− Bây giờ là lúc thêm lớp MaxPooling với filter_shape là 2 và cài đặt sải bước là 2 để nén hình ảnh xuống một nửa. MaxPooling(filter_shape=(2,2), strides=(2,2)),

Bước 11− Bây giờ, như chúng ta đã làm ở bước 9, chúng ta cần thêm một Convolutional2D khác lớp có cài đặt filter_shape là 5 và cài đặt sải bước là 1, hãy sử dụng 16 bộ lọc. Ngoài ra, hãy bật phần đệm để giữ lại kích thước của hình ảnh do lớp gộp trước đó tạo ra. Convolution2D(filter_shape=(5,5), strides=(1,1), num_filters=16, pad=True),

Bước 12− Bây giờ, như chúng ta đã làm ở bước 10, hãy thêm một lớp MaxPooling khác với một filter_shape cài đặt 3 và sải bước cài đặt 3 để giảm hình ảnh xuống một phần ba. MaxPooling(filter_shape=(3,3), strides=(3,3)),

Bước 13− Cuối cùng, thêm một Lớp dày đặc với 10 nơ-ron cho 10 lớp có thể mà mạng có thể dự đoán. Để biến mạng thành mô hình phân loại, hãy sử dụng chức năng kích hoạt log_siftmax. Dense(10, activation=log_softmax)])Ví dụ hoàn chỉnh để tạo cấu trúc CNN

from cntk.layers import Convolution2D, Sequential, Dense, MaxPooling
from cntk.ops import log_softmax, relu
from cntk.initializer import glorot_uniform
from cntk import input_variable, default_options
features = input_variable((3,28,28))
labels = input_variable(10)
with default_options(initialization=glorot_uniform, activation=relu):
model = Sequential([
   Convolution2D(filter_shape=(5,5), strides=(1,1), num_filters=8, pad=True),
MaxPooling(filter_shape=(2,2), strides=(2,2)),
   Convolution2D(filter_shape=(5,5), strides=(1,1), num_filters=16, pad=True),
MaxPooling(filter_shape=(3,3), strides=(3,3)),
Dense(10, activation=log_softmax)
])
z = model(features)

Đào tạo CNN bằng hình ảnh

Khi chúng ta đã tạo xong cấu trúc của mạng, đã đến lúc đào tạo mạng. Nhưng trước khi bắt đầu đào tạo mạng, chúng ta cần thiết lập các nguồn minibatch, vì việc đào tạo một NN hoạt động với hình ảnh đòi hỏi nhiều bộ nhớ hơn hầu hết các máy tính.

Chúng tôi đã tạo nguồn minibatch trong các phần trước. Sau đây là mã Python để thiết lập hai nguồn minibatch –

Vì có hàm create_datasource nên giờ đây chúng tôi có thể tạo hai nguồn dữ liệu riêng biệt (một nguồn đào tạo và thử nghiệm) để đào tạo mô hình.< /span>

train_datasource = create_datasource('mnist_train')
test_datasource = create_datasource('mnist_test', max_sweeps=1, train=False)

Bây giờ, khi chúng ta đã chuẩn bị xong các hình ảnh, chúng ta có thể bắt đầu huấn luyện NN của mình. Như chúng ta đã làm ở các phần trước, chúng ta có thể sử dụng phương thức train trên hàm loss để bắt đầu quá trình huấn luyện. Sau đây là mã cho việc này

from cntk import Function
from cntk.losses import cross_entropy_with_softmax
from cntk.metrics import classification_error
from cntk.learners import sgd
@Function
def criterion_factory(output, targets):
loss = cross_entropy_with_softmax(output, targets)
metric = classification_error(output, targets)
return loss, metric
loss = criterion_factory(z, labels)
learner = sgd(z.parameters, lr=0.2)

Với sự trợ giúp của mã trước đó, chúng tôi đã thiết lập phần mất và phần học cho NN. Đoạn mã sau sẽ huấn luyện và xác thực NN−

from cntk.logging import ProgressPrinter
from cntk.train import TestConfig
progress_writer = ProgressPrinter(0)
test_config = TestConfig(test_datasource)
input_map = {
   features: train_datasource.streams.features,
   labels: train_datasource.streams.labels
}
loss.train(train_datasource,
     max_epochs=10,
     minibatch_size=64,
     epoch_size=60000,
        parameter_learners=[learner],
     model_inputs_to_streams=input_map,
     callbacks=[progress_writer, test_config])

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

from cntk.layers import Convolution2D, Sequential, Dense, MaxPooling
from cntk.ops import log_softmax, relu
from cntk.initializer import glorot_uniform
from cntk import input_variable, default_options
features = input_variable((3,28,28))
labels = input_variable(10)
with default_options(initialization=glorot_uniform, activation=relu):
model = Sequential([
   Convolution2D(filter_shape=(5,5), strides=(1,1), num_filters=8, pad=True),
MaxPooling(filter_shape=(2,2), strides=(2,2)),
   Convolution2D(filter_shape=(5,5), strides=(1,1), num_filters=16, pad=True),
MaxPooling(filter_shape=(3,3), strides=(3,3)),
Dense(10, activation=log_softmax)
])
z = model(features)
import os
from cntk.io import MinibatchSource, StreamDef, StreamDefs, ImageDeserializer, INFINITELY_REPEAT
import cntk.io.transforms as xforms
def create_datasource(folder, train=True, max_sweeps=INFINITELY_REPEAT):
   mapping_file = os.path.join(folder, 'mapping.bin')
   image_transforms = []
   if train:
    image_transforms += [
     xforms.crop(crop_type='randomside', side_ratio=0.8),
     xforms.scale(width=28, height=28, channels=3, interpolations='linear')
]
   stream_definitions = StreamDefs(
   features=StreamDef(field='image', transforms=image_transforms),
    labels=StreamDef(field='label', shape=10)
)
   deserializer = ImageDeserializer(mapping_file, stream_definitions)
return MinibatchSource(deserializer, max_sweeps=max_sweeps)
train_datasource = create_datasource('mnist_train')
test_datasource = create_datasource('mnist_test', max_sweeps=1, train=False)
from cntk import Function
from cntk.losses import cross_entropy_with_softmax
from cntk.metrics import classification_error
from cntk.learners import sgd
@Function
def criterion_factory(output, targets):
   loss = cross_entropy_with_softmax(output, targets)
   metric = classification_error(output, targets)
return loss, metric
loss = criterion_factory(z, labels)
learner = sgd(z.parameters, lr=0.2)
from cntk.logging import ProgressPrinter
from cntk.train import TestConfig
progress_writer = ProgressPrinter(0)
test_config = TestConfig(test_datasource)
input_map = {
   features: train_datasource.streams.features,
   labels: train_datasource.streams.labels
}
loss.train(train_datasource,
     max_epochs=10,
     minibatch_size=64,
     epoch_size=60000,
        parameter_learners=[learner],
     model_inputs_to_streams=input_map,
     callbacks=[progress_writer, test_config])

đầu ra :

-------------------------------------------------------------------
average  since  average  since  examples
loss     last   metric   last
------------------------------------------------------
Learning rate per minibatch: 0.2
142      142      0.922   0.922    64
1.35e+06 1.51e+07 0.896   0.883    192
[………]

Biến đổi hình ảnh

Như chúng ta đã thấy, rất khó để huấn luyện NN được sử dụng để nhận dạng hình ảnh và chúng cũng cần rất nhiều dữ liệu để huấn luyện. Một vấn đề nữa là chúng có xu hướng quá phù hợp với hình ảnh được sử dụng trong quá trình đào tạo. Chúng ta hãy xem bằng một ví dụ, khi chúng ta có ảnh các khuôn mặt ở tư thế thẳng đứng, người mẫu của chúng ta sẽ gặp khó khăn trong việc nhận dạng các khuôn mặt bị xoay theo hướng khác.

Để khắc phục vấn đề này, chúng ta có thể sử dụng tính năng tăng cường hình ảnh và CNTK hỗ trợ các phép biến đổi cụ thể khi tạo nguồn minibatch cho hình ảnh. Chúng ta có thể sử dụng một số phép biến đổi như sau−

• Chúng ta có thể cắt ngẫu nhiên các hình ảnh được sử dụng để đào tạo chỉ bằng một vài dòng mã.
• Chúng ta cũng có thể sử dụng thang đo và màu sắc.

Hãy xem với sự trợ giúp của mã Python sau đây, cách chúng ta có thể thay đổi danh sách các phép biến đổi bằng cách đưa phép biến đổi cắt xén vào trong hàm được sử dụng để tạo nguồn minibatch trước đó

import os
from cntk.io import MinibatchSource, StreamDef, StreamDefs, ImageDeserializer, INFINITELY_REPEAT
import cntk.io.transforms as xforms
def create_datasource(folder, train=True, max_sweeps=INFINITELY_REPEAT):
   mapping_file = os.path.join(folder, 'mapping.bin')
   image_transforms = []
   if train:
   image_transforms += [
     xforms.crop(crop_type='randomside', side_ratio=0.8),
xforms.scale(width=28, height=28, channels=3, interpolations='linear')
]
   stream_definitions = StreamDefs(
   features=StreamDef(field='image', transforms=image_transforms),
labels=StreamDef(field='label', shape=10)
)
   deserializer = ImageDeserializer(mapping_file, stream_definitions)
return MinibatchSource(deserializer, max_sweeps=max_sweeps)

Với sự trợ giúp của đoạn mã trên, chúng ta có thể nâng cao chức năng để bao gồm một tập hợp các biến đổi hình ảnh, để khi đào tạo, chúng ta có thể cắt hình ảnh một cách ngẫu nhiên để có được nhiều biến thể hơn của hình ảnh.

Xem thêm : CNTK – Mạng thần kinh tái phát

The post CNTK – Mạng thần kinh tích chập appeared first on Dongthoigian.

Trong các phần trước, chúng tôi đã thực hiện một số xác nhận trên các mô hình NN của mình. Tuy nhiên, việc giám sát mô hình của chúng tôi trong quá trình đào tạo có cần thiết và có thể thực hiện được không?

Có, chúng tôi đã sử dụng lớp ProgressWriter để giám sát mô hình của mình và có nhiều cách khác để làm điều đó. Trước khi đi sâu vào các cách, trước tiên chúng ta hãy xem cách hoạt động của tính năng giám sát trong CNTK và cách chúng ta có thể sử dụng tính năng này để phát hiện sự cố trong mô hình NN của mình.

Cuộc gọi lại trong CNTK

Trên thực tế, trong quá trình đào tạo và xác thực, CNTK cho phép chúng tôi chỉ định lệnh gọi lại ở một số vị trí trong API. Trước tiên, chúng ta hãy xem xét kỹ hơn khi CNTK gọi lại lệnh gọi lại.

Khi CNTK gọi lại cuộc gọi?

CNTK sẽ gọi lại các cuộc gọi lại tại thời điểm tập huấn luyện và kiểm tra khi−

• Một minibatch đã được hoàn thành.
• Việc quét toàn bộ tập dữ liệu được hoàn thành trong quá trình đào tạo.
• Một đợt thử nghiệm nhỏ đã được hoàn thành.
• Việc quét toàn bộ tập dữ liệu được hoàn thành trong quá trình thử nghiệm.

Chỉ định cuộc gọi lại

Trong khi làm việc với CNTK, chúng tôi có thể chỉ định lệnh gọi lại ở một số vị trí trong API. Ví dụ-

Khi gọi train về chức năng mất?

Ở đây, khi gọi train trên một hàm loss, chúng ta có thể chỉ định một tập hợp các lệnh gọi lại thông qua đối số callbacks như sau−

training_summary=loss.train((x_train,y_train),
parameter_learners=[learner],
callbacks=[progress_writer]),
minibatch_size=16, max_epochs=15)

Khi làm việc với các nguồn minibatch hoặc sử dụng vòng lặp minibatch thủ công−

Trong trường hợp này, chúng ta có thể chỉ định lệnh gọi lại cho mục đích giám sát trong khi tạo Huấn luyện viên như sau

from cntk.logging import ProgressPrinter
callbacks = [
   ProgressPrinter(0)
]
Trainer = Trainer(z, (loss, metric), learner, [callbacks])

Các công cụ giám sát khác nhau

Hãy để chúng tôi nghiên cứu về các công cụ giám sát khác nhau.

Tiến độ Máy in

Khi đọc hướng dẫn này, bạn sẽ thấy ProgressPrinter là công cụ giám sát được sử dụng nhiều nhất. Một số đặc điểm của công cụ giám sát ProgressPrinter là−

Lớp ProgressPrinter triển khai ghi nhật ký cơ bản dựa trên bảng điều khiển để giám sát mô hình của chúng tôi. Nó có thể đăng nhập vào đĩa mà chúng ta muốn.

Đặc biệt hữu ích khi làm việc trong kịch bản đào tạo phân tán.

Nó cũng rất hữu ích khi làm việc trong tình huống mà chúng ta không thể đăng nhập vào bảng điều khiển để xem đầu ra của chương trình Python.

Với sự trợ giúp của đoạn mã sau, chúng ta có thể tạo một phiên bản của ProgressPrinter− ProgressPrinter(0, log_to_file=’test.txt’)Chúng ta sẽ nhận được kết quả đầu ra mà chúng ta đã thấy trong các phần trước−

Test.txt
CNTKCommandTrainInfo: train : 300
CNTKCommandTrainInfo: CNTKNoMoreCommands_Total : 300
CNTKCommandTrainBegin: train

-------------------------------------------------------------------
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
[………]
TensorBoard

Một trong những nhược điểm của việc sử dụng ProgressPrinter là chúng ta không thể có cái nhìn rõ ràng về mức độ khó khăn của việc mất mát và tiến triển số liệu theo thời gian. TensorBoardProgressWriter là một sự thay thế tuyệt vời cho lớp ProgressPrinter trong CNTK.

Trước khi sử dụng nó, trước tiên chúng ta cần cài đặt nó với sự trợ giúp của lệnh sau – pip install tensorboardBây giờ, để sử dụng TensorBoard, chúng ta cần thiết lập TensorBoardProgressWriter trong mã đào tạo của mình như sau−

import time
from cntk.logging import TensorBoardProgressWriter
tensorbrd_writer = TensorBoardProgressWriter(log_dir=’logs/{}’.format(time.time()),freq=1,model=z)

Bạn nên gọi phương thức đóng trên phiên bản TensorBoardProgressWriter sau khi hoàn tất việc đào tạo NNmô hình.

Chúng ta có thể trực quan hóa dữ liệu ghi nhật ký TensorBoard với sự trợ giúp của lệnh sau − Tensorboard –logdir logs

Xem thêm : CNTK – Mạng thần kinh tích chập

The post CNTK – Giám sát mô hình appeared first on Dongthoigian.

Ở đâ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

The post CNTK – Bộ dữ liệu hết bộ nhớ appeared first on Dongthoigian.

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ớ

The post CNTK – Mô hình hồi quy appeared first on Dongthoigian.

Như chúng ta có thể thấy, ma trận nhầm lẫn mẫu ở trên chứa 2 cột, một cột dành cho gian lận lớp và cột còn lại dành cho lớp bình thường. Tương tự như vậy, chúng ta có 2 hàng, một hàng được thêm vào cho lớp gian lận và một hàng được thêm vào cho lớp bình thường. Sau đây là giải thích về các thuật ngữ liên quan đến ma trận nhầm lẫn –

• Giá trị tích cực thực sự − Khi cả lớp thực tế & lớp điểm dữ liệu được dự đoán là 1.
• Phủ định thực sự − Khi cả lớp thực tế & lớp điểm dữ liệu được dự đoán là 0.
• Dương tính giả − Khi lớp điểm dữ liệu thực tế là 0 & lớp điểm dữ liệu được dự đoán là 1.
• Phủ định sai − Khi lớp điểm dữ liệu thực tế là 1 & lớp điểm dữ liệu được dự đoán là 0.

Hãy xem cách chúng ta có thể tính toán số lượng những thứ khác nhau từ ma trận nhầm lẫn – Độ chính xác − Đó là số lượng dự đoán đúng do mô hình phân loại ML của chúng tôi đưa ra. Nó có thể được tính bằng công thức sau

Độ chính xác −Nó cho chúng tôi biết có bao nhiêu mẫu được dự đoán chính xác trong số tất cả các mẫu mà chúng tôi dự đoán. Nó có thể được tính toán với sự trợ giúp của công thức sau –

Thu hồi hoặc Độ nhạy − Thu hồi là số lượng kết quả dương tính được mô hình phân loại ML của chúng tôi trả về. Nói cách khác, nó cho chúng ta biết có bao nhiêu trường hợp gian lận trong tập dữ liệu đã được mô hình thực sự phát hiện. Nó có thể được tính bằng công thức sau

Tính đặc hiệu − Ngược lại với việc thu hồi, nó đưa ra số lượng âm bản được mô hình phân loại ML của chúng tôi trả về. Nó có thể được tính bằng công thức sau

thước đo F

Chúng ta có thể sử dụng thước đo F thay thế cho ma trận nhầm lẫn. Lý do chính đằng sau điều này là chúng tôi không thể tối đa hóa Thu hồi và Độ chính xác cùng một lúc. Có mối quan hệ rất chặt chẽ giữa các số liệu này và có thể hiểu được điều đó nhờ sự trợ giúp của ví dụ sau –

Giả sử chúng ta muốn sử dụng mô hình DL để phân loại các mẫu tế bào là ung thư hay bình thường. Ở đây, để đạt được độ chính xác tối đa, chúng ta cần giảm số lượng dự đoán xuống còn 1. Mặc dù điều này có thể mang lại cho chúng ta độ chính xác khoảng 100%, nhưng khả năng thu hồi sẽ trở nên rất thấp.

Mặt khác, nếu muốn đạt mức thu hồi tối đa, chúng ta cần đưa ra càng nhiều dự đoán càng tốt. Mặc dù điều này có thể giúp chúng tôi đạt được khoảng 100% thu hồi, nhưng độ chính xác sẽ trở nên rất thấp. Trong thực tế, chúng ta cần tìm cách cân bằng giữa độ chính xác và khả năng thu hồi. Số liệu đo F cho phép chúng tôi làm như vậy vì nó biểu thị mức trung bình hài hòa giữa độ chính xác và khả năng thu hồi.

Công thức này được gọi là thước đo F1, trong đó thuật ngữ bổ sung có tên B được đặt thành 1 để có tỷ lệ chính xác và thu hồi bằng nhau. Để nhấn mạnh khả năng thu hồi, chúng ta có thể đặt hệ số B thành 2. Mặt khác, để nhấn mạnh độ chính xác, chúng ta có thể đặt hệ số B thành 0,5.

Sử dụng CNTK để đo hiệu suất phân loại

Trong phần trước, chúng tôi đã tạo một mô hình phân loại bằng cách sử dụng tập dữ liệu hoa Iris. Ở đây, chúng tôi sẽ đo lường hiệu suất của nó bằng cách sử dụng ma trận nhầm lẫn và thước đo F.

Tạo ma trận nhầm lẫn

Chúng tôi đã tạo mô hình nên có thể bắt đầu quá trình xác thực, bao gồm ma trận nhầm lẫn, trên cùng một mô hình. Đầu tiên, chúng ta sẽ tạo ma trận nhầm lẫn với sự trợ giúp của hàm confusion_matrix từ scikit-learn. Để làm được điều này, chúng tôi cần nhãn thực cho các mẫu thử nghiệm của mình và nhãn dự đoán cho cùng một mẫu thử nghiệm. Hãy tính ma trận nhầm lẫn bằng cách sử dụng mã python sau

from sklearn.metrics import confusion_matrix
y_true = np.argmax(y_test, axis=1)
y_pred = np.argmax(z(X_test), axis=1)
matrix = confusion_matrix(y_true=y_true, y_pred=y_pred)
print(matrix)

đầu ra

[[10 0 0]
[ 0 1 9]
[ 0 0 10]]

Chúng ta cũng có thể sử dụng chức năng bản đồ nhiệt để trực quan hóa ma trận nhầm lẫn như sau

import seaborn as sns
import matplotlib.pyplot as plt
g = sns.heatmap(matrix,
     annot=True,
     xticklabels=label_encoder.classes_.tolist(),
     yticklabels=label_encoder.classes_.tolist(),
     cmap='Blues')
g.set_yticklabels(g.get_yticklabels(), rotation=0)
plt.show()

Chúng ta cũng nên có một con số hiệu suất duy nhất mà chúng ta có thể sử dụng để so sánh mô hình. Để làm điều này, chúng ta cần tính toán lỗi phân loại bằng cách sử dụng hàm classification_error, từ gói số liệu trong CNTK như đã thực hiện khi tạo mô hình phân loại. Bây giờ để tính toán lỗi phân loại, hãy thực hiện phương pháp kiểm tra hàm mất mát bằng một tập dữ liệu. Sau đó, CNTK sẽ lấy các mẫu mà chúng tôi cung cấp làm đầu vào cho chức năng này và đưa ra dự đoán dựa trên các tính năng đầu vào X_test.

loss.test([X_test, y_test])

đầu ra :

{'metric': 0.36666666666, 'samples': 30}

Thực hiện các biện pháp F

Để triển khai F-Measures, CNTK cũng bao gồm chức năng gọi là fmeasures. Chúng ta có thể sử dụng hàm này trong khi huấn luyện NN bằng cách thay thế ô cntk.metrics.classification_error bằng lệnh gọi tới cntk.losses.fmeasure khi xác định hàm nhà máy tiêu chí như sau

import cntk
@cntk.Function
def criterion_factory(output, target):
   loss = cntk.losses.cross_entropy_with_softmax(output, target)
metric = cntk.losses.fmeasure(output, target)
   return loss, metric

Sau khi sử dụng hàm cntk.losses.fmeasure, chúng ta sẽ nhận được kết quả đầu ra khác nhau cho lệnh gọi phương thức loss.test như sau

loss.test([X_test, y_test])

đầu ra:

{'metric': 0.83101488749, 'samples': 30}

Xem thêm : CNTK – Mô hình hồi quy

The post CNTK – Mô hình phân loại appeared first on Dongthoigian.

Như chúng ta biết rằng, để dự đoán một giá trị số từ một hoặc nhiều biến dự đoán, chúng ta sử dụng hồi quy. Hãy lấy một ví dụ về dự đoán giá trị trung bình của một ngôi nhà ở một trong 100 thị trấn. Để làm như vậy, chúng tôi có dữ liệu bao gồm –

• Một thống kê tội phạm cho mỗi thị trấn.
• Tuổi của những ngôi nhà ở mỗi thị trấn.
• Thước đo khoảng cách từ mỗi thị trấn đến một vị trí đắc địa.
• Tỷ lệ học sinh-giáo viên ở mỗi thị trấn.
• Một thống kê nhân khẩu học chủng tộc cho mỗi thị trấn.
• Giá trị nhà trung bình ở mỗi thị trấn.

Dựa trên năm biến dự đoán này, chúng tôi muốn dự đoán giá trị ngôi nhà trung bình. Và để làm được điều này, chúng ta có thể tạo một mô hình hồi quy tuyến tính dọc theo đường

Y = a0+a1(crime)+a2(house-age)+(a3)(distance)+(a4)(ratio)+(a5)(racial)

Trong phương trình trên –

Y là giá trị trung bình được dự đoán

a0 là hằng số và

a1 đến a5 tất cả đều là hằng số liên kết với năm yếu tố dự đoán mà chúng ta đã thảo luận ở trên.< /span>

Chúng tôi cũng có một cách tiếp cận khác là sử dụng mạng lưới thần kinh. Nó sẽ tạo ra mô hình dự đoán chính xác hơn.

Ở đây, chúng ta sẽ tạo mô hình hồi quy mạng thần kinh bằng cách sử dụng CNTK.

Đang tải tập dữ liệu

Để triển khai hồi quy Mạng thần kinh bằng CNTK, chúng tôi sẽ sử dụng tập dữ liệu giá trị ngôi nhà ở khu vực Boston. Bạn có thể tải xuống tập dữ liệu từ Kho lưu trữ máy học của UCI

Tuy nhiên, đối với chương trình triển khai của chúng tôi, chúng tôi sẽ sử dụng sáu trong số 14 biến và 100 trường hợp. Trong số 6, 5 là yếu tố dự đoán và một là giá trị dự đoán. Từ 100 trường hợp, chúng tôi sẽ sử dụng 80 trường hợp cho mục đích đào tạo và 20 trường hợp cho mục đích thử nghiệm. Giá trị mà chúng tôi muốn dự đoán là giá nhà trung bình ở một thị trấn. Hãy xem năm yếu tố dự đoán mà chúng tôi sẽ sử dụng –

• Tội phạm bình quân đầu người trong thị trấn − Chúng tôi mong đợi các giá trị nhỏ hơn sẽ được liên kết với yếu tố dự đoán này.
• Tỷ lệ chủ sở hữu − Các đơn vị ở được xây dựng trước năm 1940 – Chúng tôi kỳ vọng các giá trị nhỏ hơn sẽ được liên kết với biến dự đoán này vì giá trị lớn hơn có nghĩa là ngôi nhà cũ hơn.
• Khoảng cách từ thị trấn tới năm trung tâm việc làm ở Boston.
• Tỷ lệ học sinh trên giáo viên của trường trong khu vực.
• Một thước đo gián tiếp về tỷ lệ cư dân da đen trong thị trấn.

Chuẩn bị đào tạo & tập tin kiểm tra

Như chúng ta đã làm trước đây, trước tiên chúng ta cần chuyển đổi dữ liệu thô sang định dạng CNTK. Chúng tôi sẽ sử dụng 80 mục dữ liệu đầu tiên cho mục đích đào tạo, vì vậy định dạng CNTK được phân định bằng tab như sau

|predictors 1.612820 96.90 3.76 21.00 248.31 |medval 13.50
|predictors 0.064170 68.20 3.36 19.20 396.90 |medval 18.90
|predictors 0.097440 61.40 3.38 19.20 377.56 |medval 20.00

20 mục tiếp theo cũng được chuyển đổi sang định dạng CNTK sẽ được sử dụng cho mục đích thử nghiệm.

Xây dựng mô hình hồi quy

Trước tiên, chúng ta cần xử lý các tệp dữ liệu ở định dạng CNTK và để làm được điều đó, chúng ta sẽ sử dụng hàm trợ giúp có tên create_reader làm theo sau

def create_reader(path, input_dim, output_dim, rnd_order, sweeps):
x_strm = C.io.StreamDef(field='predictors', shape=input_dim, is_sparse=False)
y_strm = C.io.StreamDef(field='medval', shape=output_dim, is_sparse=False)
streams = C.io.StreamDefs(x_src=x_strm, y_src=y_strm)
deserial = C.io.CTFDeserializer(path, streams)
mb_src = C.io.MinibatchSource(deserial, randomize=rnd_order, max_sweeps=sweeps)
return mb_src

Tiếp theo, chúng ta cần tạo một hàm trợ giúp chấp nhận đối tượng lô nhỏ CNTK và tính toán số liệu độ chính xác tùy chỉnh.

def mb_accuracy(mb, x_var, y_var, model, delta):
   num_correct = 0
   num_wrong = 0
   x_mat = mb[x_var].asarray()
   y_mat = mb[y_var].asarray()
for i in range(mb[x_var].shape[0]):
  v = model.eval(x_mat[i])
  y = y_mat[i]
if np.abs(v[0,0] – y[0,0]) < delta:
   num_correct += 1
else:
   num_wrong += 1
return (num_correct * 100.0)/(num_correct + num_wrong)

Bây giờ, chúng ta cần đặt các đối số kiến ​​trúc cho NN của mình và cũng cung cấp vị trí của các tệp dữ liệu. Nó có thể được thực hiện với sự trợ giúp của mã python sau:

def main():
print("Using CNTK version = " + str(C.__version__) + "\n")
input_dim = 5
hidden_dim = 20
output_dim = 1
train_file = ".\\...\\" #provide the name of the training file(80 data items)
test_file = ".\\...\\" #provide the name of the test file(20 data items)

Bây giờ, với sự trợ giúp của dòng mã sau, chương trình của chúng ta sẽ tạo NN chưa được huấn luyện

X = C.ops.input_variable(input_dim, np.float32)
Y = C.ops.input_variable(output_dim, np.float32)
with C.layers.default_options(init=C.initializer.uniform(scale=0.01, seed=1)):
hLayer = C.layers.Dense(hidden_dim, activation=C.ops.tanh, name='hidLayer')(X)
oLayer = C.layers.Dense(output_dim, activation=None, name='outLayer')(hLayer)
model = C.ops.alias(oLayer)

Bây giờ, khi đã tạo mô hình kép chưa được huấn luyện, chúng ta cần thiết lập đối tượng thuật toán Người học. Chúng ta sẽ sử dụng trình học SGD và squared_error hàm mất mát

tr_loss = C.squared_error(model, Y)
max_iter = 3000
batch_size = 5
base_learn_rate = 0.02
sch=C.learning_parameter_schedule([base_learn_rate, base_learn_rate/2], minibatch_size=batch_size, epoch_size=int((max_iter*batch_size)/2))
learner = C.sgd(model.parameters, sch)
trainer = C.Trainer(model, (tr_loss), [learner])

Bây giờ, khi chúng ta hoàn thành với đối tượng Thuật toán học tập, chúng ta cần tạo một hàm reader để đọc dữ liệu huấn luyện

rdr = create_reader(train_file, input_dim, output_dim, rnd_order=True, sweeps=C.io.INFINITELY_REPEAT)
boston_input_map = { X : rdr.streams.x_src, Y : rdr.streams.y_src }

Bây giờ là lúc đào tạo mô hình NN của chúng ta

for i in range(0, max_iter):
curr_batch = rdr.next_minibatch(batch_size, input_map=boston_input_map) trainer.train_minibatch(curr_batch)
if i % int(max_iter/10) == 0:
mcee = trainer.previous_minibatch_loss_average
acc = mb_accuracy(curr_batch, X, Y, model, delta=3.00)
print("batch %4d: mean squared error = %8.4f, accuracy = %5.2f%% " \ % (i, mcee, acc)

Khi chúng ta đã hoàn thành việc đào tạo, hãy đánh giá mô hình bằng cách sử dụng các mục dữ liệu thử nghiệm –

print("\nEvaluating test data \n")
rdr = create_reader(test_file, input_dim, output_dim, rnd_order=False, sweeps=1)
boston_input_map = { X : rdr.streams.x_src, Y : rdr.streams.y_src }
num_test = 20
all_test = rdr.next_minibatch(num_test, input_map=boston_input_map)
acc = mb_accuracy(all_test, X, Y, model, delta=3.00)
print("Prediction accuracy = %0.2f%%" % acc)

Sau khi đánh giá tính chính xác của mô hình NN đã được đào tạo của chúng tôi, chúng tôi sẽ sử dụng nó để đưa ra dự đoán về dữ liệu chưa nhìn thấy –

np.set_printoptions(precision = 2, suppress=True)
unknown = np.array([[0.09, 50.00, 4.5, 17.00, 350.00], dtype=np.float32)
print("\nPredicting median home value for feature/predictor values: ")
print(unknown[0])
pred_prob = model.eval({X: unknown)
print("\nPredicted value is: ")
print(“$%0.2f (x1000)” %pred_value[0,0])

Mô hình hồi quy hoàn chỉnh

import numpy as np
import cntk as C
def create_reader(path, input_dim, output_dim, rnd_order, sweeps):
x_strm = C.io.StreamDef(field='predictors', shape=input_dim, is_sparse=False)
y_strm = C.io.StreamDef(field='medval', shape=output_dim, is_sparse=False)
streams = C.io.StreamDefs(x_src=x_strm, y_src=y_strm)
deserial = C.io.CTFDeserializer(path, streams)
mb_src = C.io.MinibatchSource(deserial, randomize=rnd_order, max_sweeps=sweeps)
return mb_src
def mb_accuracy(mb, x_var, y_var, model, delta):
num_correct = 0
num_wrong = 0
x_mat = mb[x_var].asarray()
y_mat = mb[y_var].asarray()
for i in range(mb[x_var].shape[0]):
   v = model.eval(x_mat[i])
   y = y_mat[i]
if np.abs(v[0,0] – y[0,0]) < delta:
   num_correct += 1
else:
   num_wrong += 1
return (num_correct * 100.0)/(num_correct + num_wrong)
def main():
print("Using CNTK version = " + str(C.__version__) + "\n")
input_dim = 5
hidden_dim = 20
output_dim = 1
train_file = ".\\...\\" #provide the name of the training file(80 data items)
test_file = ".\\...\\" #provide the name of the test file(20 data items)
X = C.ops.input_variable(input_dim, np.float32)
Y = C.ops.input_variable(output_dim, np.float32)
with C.layers.default_options(init=C.initializer.uniform(scale=0.01, seed=1)):
hLayer = C.layers.Dense(hidden_dim, activation=C.ops.tanh, name='hidLayer')(X)
oLayer = C.layers.Dense(output_dim, activation=None, name='outLayer')(hLayer)
model = C.ops.alias(oLayer)
tr_loss = C.squared_error(model, Y)
max_iter = 3000
batch_size = 5
base_learn_rate = 0.02
sch = C.learning_parameter_schedule([base_learn_rate, base_learn_rate/2], minibatch_size=batch_size, epoch_size=int((max_iter*batch_size)/2))
learner = C.sgd(model.parameters, sch)
trainer = C.Trainer(model, (tr_loss), [learner])
rdr = create_reader(train_file, input_dim, output_dim, rnd_order=True, sweeps=C.io.INFINITELY_REPEAT)
boston_input_map = { X : rdr.streams.x_src, Y : rdr.streams.y_src }
for i in range(0, max_iter):
curr_batch = rdr.next_minibatch(batch_size, input_map=boston_input_map) trainer.train_minibatch(curr_batch)
if i % int(max_iter/10) == 0:
   mcee = trainer.previous_minibatch_loss_average
   acc = mb_accuracy(curr_batch, X, Y, model, delta=3.00)
   print("batch %4d: mean squared error = %8.4f, accuracy = %5.2f%% " \ % (i, mcee, acc))
   print("\nEvaluating test data \n")
   rdr = create_reader(test_file, input_dim, output_dim, rnd_order=False, sweeps=1)
   boston_input_map = { X : rdr.streams.x_src, Y : rdr.streams.y_src }
   num_test = 20
all_test = rdr.next_minibatch(num_test, input_map=boston_input_map)
acc = mb_accuracy(all_test, X, Y, model, delta=3.00)
print("Prediction accuracy = %0.2f%%" % acc)
np.set_printoptions(precision = 2, suppress=True)
unknown = np.array([[0.09, 50.00, 4.5, 17.00, 350.00], dtype=np.float32)
print("\nPredicting median home value for feature/predictor values: ")
print(unknown[0])
pred_prob = model.eval({X: unknown)
print("\nPredicted value is: ")
print(“$%0.2f (x1000)” %pred_value[0,0])
if __name__== ”__main__”:
   main()

đầu ra

Using CNTK version = 2.7batch 0: mean squared error = 385.6727, accuracy = 0.00%batch 300: mean squared error = 41.6229, accuracy = 20.00%batch 600: mean squared error = 28.7667, accuracy = 40.00%batch 900: mean squared error = 48.6435, accuracy = 40.00%batch 1200: mean squared error = 77.9562, accuracy = 80.00%batch 1500: mean squared error = 7.8342, accuracy = 60.00%batch 1800: mean squared error = 47.7062, accuracy = 60.00%batch 2100: mean squared error = 40.5068, accuracy = 40.00%batch 2400: mean squared error = 46.5023, accuracy = 40.00%batch 2700: mean squared error = 15.6235, accuracy = 60.00%Evaluating test dataPrediction accuracy = 64.00%Predicting median home value for feature/predictor values:[0.09 50. 4.5 17. 350.]Predicted value is:$21.02(x1000)

Lưu mô hình được đào tạo

Bộ dữ liệu giá trị Ngôi nhà Boston này chỉ có 506 mục dữ liệu (trong đó chúng tôi chỉ kiện 100 mục). Do đó, sẽ chỉ mất vài giây để huấn luyện mô hình hồi quy NN, nhưng việc huấn luyện trên một tập dữ liệu lớn có hàng trăm hoặc hàng nghìn mục dữ liệu có thể mất hàng giờ hoặc thậm chí vài ngày.

Chúng ta có thể lưu mô hình của mình để không phải giữ lại mô hình đó từ đầu. Với sự trợ giúp của mã Python sau, chúng ta có thể lưu NN đã đào tạo của mình – nn_regressor = “.\\neuralregressor.model” #provide the name of the filemodel.save(nn_regressor, format=C.ModelFormat.CNTKv2)

Sau đây là các đối số của hàm save() được sử dụng ở trên:

• Tên tệp là đối số đầu tiên của hàm save(). Nó cũng có thể được viết cùng với đường dẫn của tập tin.
• Một tham số khác là tham số format có giá trị mặc định C.ModelFormat.CNTKv2.

Đang tải mô hình được đào tạo

Khi bạn đã lưu mô hình đã đào tạo, việc tải mô hình đó rất dễ dàng. Chúng ta chỉ cần sử dụng hàm Load() là được. Hãy kiểm tra điều này trong ví dụ sau

import numpy as np
import cntk as C
model = C.ops.functions.Function.load(“.\\neuralregressor.model”)
np.set_printoptions(precision = 2, suppress=True)
unknown = np.array([[0.09, 50.00, 4.5, 17.00, 350.00], dtype=np.float32)
print("\nPredicting area median home value for feature/predictor values: ")
print(unknown[0])
pred_prob = model.eval({X: unknown)
print("\nPredicted value is: ")
print(“$%0.2f (x1000)” %pred_value[0,0])

Lợi ích của mô hình đã lưu là khi bạn tải mô hình đã lưu, nó có thể được sử dụng chính xác như thể mô hình vừa được đào tạo.

Xem thêm : CNTK – Mô hình phân loại

The post CNTK – Hồi quy mạng thần kinh appeared first on Dongthoigian.

Đang tải tập dữ liệu

Để triển khai cả hai kỹ thuật này bằng NN, chúng tôi sẽ sử dụng tập dữ liệu tiền giấy. Bạn có thể tải xuống tập dữ liệu từ Kho lưu trữ máy học UCI tại https://archive.ics.uci.edu/ml/datasets/banknote+authentication.

Trong ví dụ của chúng tôi, chúng tôi sẽ sử dụng 50 mục dữ liệu xác thực có giả mạo lớp = 0 và 50 mục giả đầu tiên có giả mạo lớp = 1

Chuẩn bị đào tạo & tập tin kiểm tra

Có 1372 mục dữ liệu trong tập dữ liệu đầy đủ. Tập dữ liệu thô trông như sau

Chuẩn bị đào tạo & tập tin kiểm tra
Có 1372 mục dữ liệu trong tập dữ liệu đầy đủ. Tập dữ liệu thô trông như sau -
3.6216, 8.6661, -2.8076, -0.44699, 0
4.5459, 8.1674, -2.4586, -1.4621, 0
…
-1.3971, 3.3191, -1.3927, -1.9948, 1
0.39012, -0.14279, -0.031994, 0.35084, 1

Bây giờ, trước tiên chúng ta cần chuyển đổi dữ liệu thô này thành định dạng CNTK hai nút, như sau

stats 3.62160000 8.66610000 -2.80730000 -0.44699000 |forgery 0 1 |# authentic 
|stats 4.54590000 8.16740000 -2.45860000 -1.46210000 |forgery 0 1 |# authentic 
. . .
|stats -1.39710000 3.31910000 -1.39270000 -1.99480000 |forgery 1 0 |# fake 
|stats 0.39012000 -0.14279000 -0.03199400 0.35084000 |forgery 1 0 |# fake

Bạn có thể sử dụng chương trình python sau để tạo dữ liệu định dạng CNTK từ Dữ liệu thô

fin = open(".\\...", "r") #provide the location of saved dataset text file.
for line in fin:
   line = line.strip()
   tokens = line.split(",")
   if tokens[4] == "0":
    print("|stats %12.8f %12.8f %12.8f %12.8f |forgery 0 1 |# authentic" % \
(float(tokens[0]), float(tokens[1]), float(tokens[2]), float(tokens[3])) )
   else:
    print("|stats %12.8f %12.8f %12.8f %12.8f |forgery 1 0 |# fake" % \
(float(tokens[0]), float(tokens[1]), float(tokens[2]), float(tokens[3])) )
fin.close()

Mô hình phân loại nhị phân hai nút

Có rất ít sự khác biệt giữa phân loại hai nút và phân loại nhiều lớp. Ở đây, trước tiên, chúng ta cần xử lý các tệp dữ liệu ở định dạng CNTK và để làm được điều đó, chúng ta sẽ sử dụng hàm trợ giúp có tên create_reader như sau

def create_reader(path, input_dim, output_dim, rnd_order, sweeps):
x_strm = C.io.StreamDef(field='stats', shape=input_dim, is_sparse=False)
y_strm = C.io.StreamDef(field='forgery', shape=output_dim, is_sparse=False)
streams = C.io.StreamDefs(x_src=x_strm, y_src=y_strm)
deserial = C.io.CTFDeserializer(path, streams)
mb_src = C.io.MinibatchSource(deserial, randomize=rnd_order, max_sweeps=sweeps)
return mb_src

Bây giờ, chúng ta cần đặt các đối số kiến ​​trúc cho NN của mình và cũng cung cấp vị trí của các tệp dữ liệu. Nó có thể được thực hiện với sự trợ giúp của mã python sau:

def main():
print("Using CNTK version = " + str(C.__version__) + "\n")
input_dim = 4
hidden_dim = 10
output_dim = 2
train_file = ".\\...\\" #provide the name of the training file
test_file = ".\\...\\" #provide the name of the test file

Bây giờ, với sự trợ giúp của dòng mã sau, chương trình của chúng ta sẽ tạo NN chưa được huấn luyện –

X = C.ops.input_variable(input_dim, np.float32)
Y = C.ops.input_variable(output_dim, np.float32)
with C.layers.default_options(init=C.initializer.uniform(scale=0.01, seed=1)):
hLayer = C.layers.Dense(hidden_dim, activation=C.ops.tanh, name='hidLayer')(X)
oLayer = C.layers.Dense(output_dim, activation=None, name='outLayer')(hLayer)
nnet = oLayer
model = C.ops.softmax(nnet)

Bây giờ, khi đã tạo mô hình kép chưa được huấn luyện, chúng ta cần thiết lập đối tượng thuật toán Người học và sau đó sử dụng nó để tạo đối tượng đào tạo Huấn luyện viên. Chúng ta sẽ sử dụng hàm học SGD và hàm mất mát cross_entropy_with_softmax −

tr_loss = C.cross_entropy_with_softmax(nnet, Y)
tr_clas = C.classification_error(nnet, Y)
max_iter = 500
batch_size = 10
learn_rate = 0.01
learner = C.sgd(nnet.parameters, learn_rate)
trainer = C.Trainer(nnet, (tr_loss, tr_clas), [learner])

Bây giờ, khi chúng ta đã hoàn thành với đối tượng Trainer, chúng ta cần tạo một hàm reader để đọc dữ liệu huấn luyện –

rdr = create_reader(train_file, input_dim, output_dim, rnd_order=True, sweeps=C.io.INFINITELY_REPEAT)
banknote_input_map = { X : rdr.streams.x_src, Y : rdr.streams.y_src }

Bây giờ là lúc đào tạo mô hình NN của chúng ta –

for i in range(0, max_iter):
curr_batch = rdr.next_minibatch(batch_size, input_map=iris_input_map) trainer.train_minibatch(curr_batch)
if i % 500 == 0:
mcee = trainer.previous_minibatch_loss_average
macc = (1.0 - trainer.previous_minibatch_evaluation_average) * 100
print("batch %4d: mean loss = %0.4f, accuracy = %0.2f%% " \ % (i, mcee, macc))

Sau khi quá trình đào tạo hoàn tất, chúng ta hãy đánh giá mô hình bằng cách sử dụng các mục dữ liệu thử nghiệm −

print("\nEvaluating test data \n")
rdr = create_reader(test_file, input_dim, output_dim, rnd_order=False, sweeps=1)
banknote_input_map = { X : rdr.streams.x_src, Y : rdr.streams.y_src }
num_test = 20
all_test = rdr.next_minibatch(num_test, input_map=iris_input_map) acc = (1.0 - trainer.test_minibatch(all_test)) * 100
print("Classification accuracy = %0.2f%%" % acc)

Sau khi đánh giá độ chính xác của mô hình NN đã được đào tạo của chúng tôi, chúng tôi sẽ sử dụng nó để đưa ra dự đoán về dữ liệu chưa nhìn thấy

np.set_printoptions(precision = 1, suppress=True)
unknown = np.array([[0.6, 1.9, -3.3, -0.3]], dtype=np.float32)
print("\nPredicting Banknote authenticity for input features: ")
print(unknown[0])
pred_prob = model.eval(unknown)
np.set_printoptions(precision = 4, suppress=True)
print("Prediction probabilities are: ")
print(pred_prob[0])
if pred_prob[0,0] < pred_prob[0,1]:
  print(“Prediction: authentic”)
else:
  print(“Prediction: fake”)

Mô hình phân loại hai nút hoàn chỉnh

def create_reader(path, input_dim, output_dim, rnd_order, sweeps):
x_strm = C.io.StreamDef(field='stats', shape=input_dim, is_sparse=False)
y_strm = C.io.StreamDef(field='forgery', shape=output_dim, is_sparse=False)
streams = C.io.StreamDefs(x_src=x_strm, y_src=y_strm)
deserial = C.io.CTFDeserializer(path, streams)
mb_src = C.io.MinibatchSource(deserial, randomize=rnd_order, max_sweeps=sweeps)
return mb_src
def main():
print("Using CNTK version = " + str(C.__version__) + "\n")
input_dim = 4
hidden_dim = 10
output_dim = 2
train_file = ".\\...\\" #provide the name of the training file
test_file = ".\\...\\" #provide the name of the test file
X = C.ops.input_variable(input_dim, np.float32)
Y = C.ops.input_variable(output_dim, np.float32)
withC.layers.default_options(init=C.initializer.uniform(scale=0.01, seed=1)):
hLayer = C.layers.Dense(hidden_dim, activation=C.ops.tanh, name='hidLayer')(X)
oLayer = C.layers.Dense(output_dim, activation=None, name='outLayer')(hLayer)
nnet = oLayer
model = C.ops.softmax(nnet)
tr_loss = C.cross_entropy_with_softmax(nnet, Y)
tr_clas = C.classification_error(nnet, Y)
max_iter = 500
batch_size = 10
learn_rate = 0.01
learner = C.sgd(nnet.parameters, learn_rate)
trainer = C.Trainer(nnet, (tr_loss, tr_clas), [learner])
rdr = create_reader(train_file, input_dim, output_dim, rnd_order=True, sweeps=C.io.INFINITELY_REPEAT)
banknote_input_map = { X : rdr.streams.x_src, Y : rdr.streams.y_src }
for i in range(0, max_iter):
curr_batch = rdr.next_minibatch(batch_size, input_map=iris_input_map) trainer.train_minibatch(curr_batch)
if i % 500 == 0:
mcee = trainer.previous_minibatch_loss_average
macc = (1.0 - trainer.previous_minibatch_evaluation_average) * 100
print("batch %4d: mean loss = %0.4f, accuracy = %0.2f%% " \ % (i, mcee, macc))
print("\nEvaluating test data \n")
rdr = create_reader(test_file, input_dim, output_dim, rnd_order=False, sweeps=1)
banknote_input_map = { X : rdr.streams.x_src, Y : rdr.streams.y_src }
num_test = 20
all_test = rdr.next_minibatch(num_test, input_map=iris_input_map) acc = (1.0 - trainer.test_minibatch(all_test)) * 100
print("Classification accuracy = %0.2f%%" % acc)
np.set_printoptions(precision = 1, suppress=True)
unknown = np.array([[0.6, 1.9, -3.3, -0.3]], dtype=np.float32)
print("\nPredicting Banknote authenticity for input features: ")
print(unknown[0])
pred_prob = model.eval(unknown)
np.set_printoptions(precision = 4, suppress=True)
print("Prediction probabilities are: ")
print(pred_prob[0])
if pred_prob[0,0] < pred_prob[0,1]:
print(“Prediction: authentic”)
else:
print(“Prediction: fake”)
if __name__== ”__main__”:
main()

đầu ra

Using CNTK version = 2.7batch 0: mean loss = 0.6928, accuracy = 80.00%batch 50: mean loss = 0.6877, accuracy = 70.00%batch 100: mean loss = 0.6432, accuracy = 80.00%batch 150: mean loss = 0.4978, accuracy = 80.00%batch 200: mean loss = 0.4551, accuracy = 90.00%batch 250: mean loss = 0.3755, accuracy = 90.00%batch 300: mean loss = 0.2295, accuracy = 100.00%batch 350: mean loss = 0.1542, accuracy = 100.00%batch 400: mean loss = 0.1581, accuracy = 100.00%batch 450: mean loss = 0.1499, accuracy = 100.00%Evaluating test dataClassification accuracy = 84.58%Predicting banknote authenticity for input features:[0.6 1.9 -3.3 -0.3]Prediction probabilities are:[0.7847 0.2536]Prediction: fake

Mô hình phân loại nhị phân một nút

Chương trình triển khai gần giống như chúng tôi đã thực hiện ở trên đối với phân loại hai nút. Thay đổi chính là khi sử dụng kỹ thuật phân loại hai nút. Chúng ta có thể sử dụng hàm phân loại_error() tích hợp sẵn của CNTK, nhưng trong trường hợp phân loại một nút, CNTK không hỗ trợ hàm phân loại_error(). Đó là lý do chúng ta cần triển khai hàm do chương trình xác định như sau

def class_acc(mb, x_var, y_var, model):num_correct = 0; num_wrong = 0x_mat = mb[x_var].asarray()y_mat = mb[y_var].asarray()for i in range(mb[x_var].shape[0]):   p = model.eval(x_mat[i]   y = y_mat[i]   if p[0,0] < 0.5 and y[0,0] == 0.0 or p[0,0] >= 0.5 and y[0,0] == 1.0:num_correct += 1 else:  num_wrong += 1return (num_correct * 100.0)/(num_correct + num_wrong)

Với sự thay đổi đó, hãy xem ví dụ phân loại một nút hoàn chỉnh – Mô hình phân loại một nút hoàn chỉnh

import numpy as np
import cntk as C
def create_reader(path, input_dim, output_dim, rnd_order, sweeps):
x_strm = C.io.StreamDef(field='stats', shape=input_dim, is_sparse=False)
y_strm = C.io.StreamDef(field='forgery', shape=output_dim, is_sparse=False)
streams = C.io.StreamDefs(x_src=x_strm, y_src=y_strm)
deserial = C.io.CTFDeserializer(path, streams)
mb_src = C.io.MinibatchSource(deserial, randomize=rnd_order, max_sweeps=sweeps)
return mb_src
def class_acc(mb, x_var, y_var, model):
num_correct = 0; num_wrong = 0
x_mat = mb[x_var].asarray()
y_mat = mb[y_var].asarray()
for i in range(mb[x_var].shape[0]):
  p = model.eval(x_mat[i]
  y = y_mat[i]
  if p[0,0] < 0.5 and y[0,0] == 0.0 or p[0,0] >= 0.5 and y[0,0] == 1.0:
  num_correct += 1
 else:
  num_wrong += 1
return (num_correct * 100.0)/(num_correct + num_wrong)
def main():
print("Using CNTK version = " + str(C.__version__) + "\n")
input_dim = 4
hidden_dim = 10
output_dim = 1
train_file = ".\\...\\" #provide the name of the training file
test_file = ".\\...\\" #provide the name of the test file
X = C.ops.input_variable(input_dim, np.float32)
Y = C.ops.input_variable(output_dim, np.float32)
with C.layers.default_options(init=C.initializer.uniform(scale=0.01, seed=1)):
hLayer = C.layers.Dense(hidden_dim, activation=C.ops.tanh, name='hidLayer')(X)
oLayer = C.layers.Dense(output_dim, activation=None, name='outLayer')(hLayer)
model = oLayer
tr_loss = C.cross_entropy_with_softmax(model, Y)
max_iter = 1000
batch_size = 10
learn_rate = 0.01
learner = C.sgd(model.parameters, learn_rate)
trainer = C.Trainer(model, (tr_loss), [learner])
rdr = create_reader(train_file, input_dim, output_dim, rnd_order=True, sweeps=C.io.INFINITELY_REPEAT)
banknote_input_map = {X : rdr.streams.x_src, Y : rdr.streams.y_src }
for i in range(0, max_iter):
curr_batch = rdr.next_minibatch(batch_size, input_map=iris_input_map) trainer.train_minibatch(curr_batch)
if i % 100 == 0:
mcee=trainer.previous_minibatch_loss_average
ca = class_acc(curr_batch, X,Y, model)
print("batch %4d: mean loss = %0.4f, accuracy = %0.2f%% " \ % (i, mcee, ca))
print("\nEvaluating test data \n")
rdr = create_reader(test_file, input_dim, output_dim, rnd_order=False, sweeps=1)
banknote_input_map = { X : rdr.streams.x_src, Y : rdr.streams.y_src }
num_test = 20
all_test = rdr.next_minibatch(num_test, input_map=iris_input_map)
acc = class_acc(all_test, X,Y, model)
print("Classification accuracy = %0.2f%%" % acc)
np.set_printoptions(precision = 1, suppress=True)
unknown = np.array([[0.6, 1.9, -3.3, -0.3]], dtype=np.float32)
print("\nPredicting Banknote authenticity for input features: ")
print(unknown[0])
pred_prob = model.eval({X:unknown})
print("Prediction probability: ")
print(“%0.4f” % pred_prob[0,0])
if pred_prob[0,0] < 0.5:
  print(“Prediction: authentic”)
else:
  print(“Prediction: fake”)
if __name__== ”__main__”:
   main()

đầu ra

Using CNTK version = 2.7
batch 0: mean loss = 0.6936, accuracy = 10.00%
batch 100: mean loss = 0.6882, accuracy = 70.00%
batch 200: mean loss = 0.6597, accuracy = 50.00%
batch 300: mean loss = 0.5298, accuracy = 70.00%
batch 400: mean loss = 0.4090, accuracy = 100.00%
batch 500: mean loss = 0.3790, accuracy = 90.00%
batch 600: mean loss = 0.1852, accuracy = 100.00%
batch 700: mean loss = 0.1135, accuracy = 100.00%
batch 800: mean loss = 0.1285, accuracy = 100.00%
batch 900: mean loss = 0.1054, accuracy = 100.00%
Evaluating test data
Classification accuracy = 84.00%
Predicting banknote authenticity for input features:
[0.6 1.9 -3.3 -0.3]
Prediction probability:
0.8846
Prediction: fake

Xem thêm : CNTK – Hồi quy mạng thần kinh

The post Mạng thần kinh nhân tạo appeared first on Dongthoigian.