TensorFlow Autoencoder: Dataset with Deep Learning Ví dụ

Mục lục:

Anonim

Autoencoder là gì?

Một Autoencoder là một công cụ để mã hóa dữ liệu một cách hiệu quả một cách không có giám sát học tập. Nó là một loại mạng nơ-ron nhân tạo giúp bạn học cách biểu diễn tập dữ liệu để giảm kích thước bằng cách huấn luyện mạng nơ-ron bỏ qua nhiễu tín hiệu. Nó là một công cụ tuyệt vời để tạo lại một đầu vào.

Nói một cách dễ hiểu, máy chụp, giả sử một hình ảnh, và có thể tạo ra một bức ảnh có liên quan chặt chẽ. Đầu vào trong loại mạng nơ-ron này không có nhãn, có nghĩa là mạng có khả năng học mà không cần giám sát. Chính xác hơn, đầu vào được mạng mã hóa để chỉ tập trung vào tính năng quan trọng nhất. Đây là một trong những lý do tại sao autoencoder phổ biến để giảm kích thước. Bên cạnh đó, mã tự động có thể được sử dụng để tạo ra các mô hình học tập chung . Ví dụ, mạng nơ-ron có thể được huấn luyện với một tập hợp các khuôn mặt và sau đó có thể tạo ra các khuôn mặt mới.

Trong hướng dẫn TensorFlow Autoencoder này, bạn sẽ học:

  • Autoencoder là gì?
  • Autoencoder hoạt động như thế nào?
  • Ví dụ về trình mã tự động xếp chồng
  • Xây dựng Trình mã tự động với TensorFlow
  • Xử lý trước hình ảnh
  • Đặt công cụ ước tính tập dữ liệu
  • Xây dựng mạng

Autoencoder hoạt động như thế nào?

Mục đích của bộ mã tự động là tạo ra giá trị đầu vào gần đúng bằng cách chỉ tập trung vào các tính năng cần thiết. Bạn có thể nghĩ tại sao không chỉ đơn thuần học cách sao chép và dán đầu vào để tạo ra đầu ra. Trên thực tế, autoencoder là một tập hợp các ràng buộc buộc mạng phải học các cách mới để biểu diễn dữ liệu, khác với việc chỉ sao chép đầu ra.

Một bộ mã tự động điển hình được xác định với một đầu vào, một đại diện bên trong và một đầu ra (một giá trị gần đúng của đầu vào). Việc học tập xảy ra trong các lớp gắn với biểu diễn bên trong. Trên thực tế, có hai khối lớp chính trông giống như một mạng nơ-ron truyền thống. Sự khác biệt nhỏ là lớp chứa đầu ra phải bằng với đầu vào. Trong hình bên dưới, đầu vào ban đầu đi vào khối đầu tiên được gọi là bộ mã hóa . Biểu diễn bên trong này nén (giảm) kích thước của đầu vào. Trong khối thứ hai xảy ra quá trình tái tạo đầu vào. Đây là giai đoạn giải mã.

Hoạt động của Autoencoder

Mô hình sẽ cập nhật trọng lượng bằng cách giảm thiểu hàm mất mát. Mô hình bị phạt nếu đầu ra tái thiết khác với đầu vào.

Cụ thể, hãy tưởng tượng một bức tranh có kích thước 50x50 (tức là 250 pixel) và một mạng nơ-ron chỉ với một lớp ẩn bao gồm một trăm nơ-ron. Việc học được thực hiện trên bản đồ đặc trưng nhỏ hơn đầu vào hai lần. Nó có nghĩa là mạng cần tìm cách tái tạo lại 250 pixel chỉ với một vector nơ-ron bằng 100.

Ví dụ về trình mã tự động xếp chồng

Trong hướng dẫn Autoencoder này, bạn sẽ học cách sử dụng Autoencoder xếp chồng lên nhau. Kiến trúc tương tự như một mạng nơ-ron truyền thống. Đầu vào đi đến một lớp ẩn để được nén hoặc giảm kích thước của nó, rồi đến các lớp tái tạo. Mục tiêu là tạo ra một hình ảnh đầu ra gần giống như bản gốc. Mô hình phải học cách để đạt được nhiệm vụ của nó dưới một tập hợp các ràng buộc, nghĩa là với một thứ nguyên thấp hơn.

Ngày nay, Autoencoders trong Deep Learning chủ yếu được sử dụng để khử nhiễu hình ảnh. Hãy tưởng tượng một hình ảnh với những vết xước; một con người vẫn có thể nhận ra nội dung. Ý tưởng của việc khử mã tự động là thêm nhiễu vào hình ảnh để buộc mạng tìm hiểu mô hình đằng sau dữ liệu.

Họ hữu ích khác của Autoencoder Deep Learning là Autoencoder biến thể. Loại mạng này có thể tạo ra hình ảnh mới. Hãy tưởng tượng bạn đào tạo một mạng lưới với hình ảnh của một người đàn ông; một mạng lưới như vậy có thể tạo ra những khuôn mặt mới.

Xây dựng Trình mã tự động với TensorFlow

Trong hướng dẫn này, bạn sẽ học cách xây dựng một bộ mã tự động xếp chồng lên nhau để tạo lại hình ảnh.

Bạn sẽ sử dụng tập dữ liệu CIFAR-10 chứa 60000 hình ảnh màu 32x32. Tập dữ liệu Autoencoder đã được chia thành 50000 hình ảnh để đào tạo và 10000 hình ảnh để thử nghiệm. Có tới mười lớp:

  • Máy bay
  • Ô tô
  • Chim
  • Con mèo
  • Con nai
  • Chó
  • Ếch
  • Con ngựa
  • Tàu
  • Xe tải

Bạn cần tải xuống các hình ảnh trong URL này https://www.cs.toronto.edu/~kriz/cifar.html và giải nén nó. Thư mục for-10-batches-py chứa năm lô dữ liệu với 10000 hình ảnh mỗi lô theo thứ tự ngẫu nhiên.

Trước khi xây dựng và đào tạo mô hình của mình, bạn cần áp dụng một số xử lý dữ liệu. Bạn sẽ tiến hành như sau:

  1. Nhập dữ liệu
  2. Chuyển đổi dữ liệu sang định dạng đen trắng
  3. Nối tất cả các lô
  4. Xây dựng tập dữ liệu đào tạo
  5. Xây dựng trình hiển thị hình ảnh

Xử lý trước hình ảnh

Bước 1) Nhập dữ liệu.

Theo trang web chính thức, bạn có thể tải lên dữ liệu bằng đoạn mã sau. Mã Autoencoder sẽ tải dữ liệu trong từ điển với dữ liệu và nhãn . Lưu ý rằng mã là một hàm.

import numpy as npimport tensorflow as tfimport pickledef unpickle(file):import picklewith open(file, 'rb') as fo:dict = pickle.load(fo, encoding='latin1')return dict

Bước 2) Chuyển đổi dữ liệu sang định dạng đen trắng

Để đơn giản, bạn sẽ chuyển đổi dữ liệu sang thang độ xám. Đó là, chỉ với một chiều so với ba chiều cho hình ảnh màu sắc. Hầu hết mạng nơ-ron chỉ hoạt động với đầu vào một chiều.

def grayscale(im):return im.reshape(im.shape[0], 3, 32, 32).mean(1).reshape(im.shape[0], -1)

Bước 3) Nối tất cả các lô

Bây giờ cả hai hàm đã được tạo và tập dữ liệu được tải, bạn có thể viết một vòng lặp để nối thêm dữ liệu vào bộ nhớ. Nếu bạn kiểm tra kỹ, tệp giải nén với dữ liệu được đặt tên là data_batch_ với số từ 1 đến 5. Bạn có thể lặp lại các tệp và nối nó vào dữ liệu.

Khi bước này hoàn thành, bạn chuyển đổi dữ liệu màu sắc sang định dạng thang màu xám. Như bạn có thể thấy, hình dạng của dữ liệu là 50000 và 1024. 32 * 32 pixel hiện đã được làm phẳng cho năm 2014.

# Load the data into memorydata, labels = [], []## Loop over the bfor i in range(1, 6):filename = './cifar-10-batches-py/data_batch_' + str(i)open_data = unpickle(filename)if len(data)> 0:data = np.vstack((data, open_data['data']))labels = np.hstack((labels, open_data['labels']))else:data = open_data['data']labels = open_data['labels']data = grayscale(data)x = np.matrix(data)y = np.array(labels)print(x.shape)(50000, 1024)

Lưu ý: Thay đổi './cifar-10-batches-py/data_batch_' thành vị trí thực của tệp của bạn. Ví dụ đối với máy Windows, đường dẫn có thể là filename = 'E: \ cifar-10-batches-py \ data_batch_' + str (i)

Bước 4) Xây dựng tập dữ liệu đào tạo

Để làm cho việc đào tạo nhanh hơn và dễ dàng hơn, bạn sẽ chỉ đào tạo một mô hình trên hình ảnh con ngựa. Ngựa là lớp thứ bảy trong dữ liệu nhãn. Như đã đề cập trong tài liệu của bộ dữ liệu CIFAR-10, mỗi lớp chứa 5000 hình ảnh. Bạn có thể in hình dạng của dữ liệu để xác nhận có 5.000 hình ảnh với 1024 cột như được hiển thị trong bước ví dụ về TensorFlow Autoencoder dưới đây.

horse_i = np.where(y == 7)[0]horse_x = x[horse_i]print(np.shape(horse_x))(5000, 1024)

Bước 5) Xây dựng trình hiển thị hình ảnh

Cuối cùng, bạn xây dựng một hàm để vẽ các hình ảnh. Bạn sẽ cần chức năng này để in hình ảnh được tái tạo từ trình mã tự động.

Một cách dễ dàng để in hình ảnh là sử dụng đối tượng imshow từ thư viện matplotlib. Lưu ý rằng, bạn cần chuyển đổi hình dạng của dữ liệu từ 1024 sang 32 * 32 (tức là định dạng của hình ảnh).

# To plot pretty figures%matplotlib inlineimport matplotlibimport matplotlib.pyplot as pltdef plot_image(image, shape=[32, 32], cmap = "Greys_r"):plt.imshow(image.reshape(shape), cmap=cmap,interpolation="nearest")plt.axis("off")

Hàm nhận 3 đối số:

  • Hình ảnh: đầu vào
  • Hình dạng: danh sách, kích thước của hình ảnh
  • Cmap: chọn bản đồ màu. Theo mặc định, màu xám

Bạn có thể thử vẽ hình ảnh đầu tiên trong tập dữ liệu. Bạn sẽ thấy một người đàn ông trên một con ngựa.

plot_image(horse_x[1], shape=[32, 32], cmap = "Greys_r")

Đặt công cụ ước tính tập dữ liệu

Được rồi, bây giờ tập dữ liệu đã sẵn sàng để sử dụng, bạn có thể bắt đầu sử dụng Tensorflow. Trước khi xây dựng mô hình, hãy sử dụng công cụ ước tính Dataset của Tensorflow để cung cấp cho mạng.

Bạn sẽ xây dựng Tập dữ liệu với công cụ ước tính TensorFlow. Để làm mới tâm trí, bạn cần sử dụng:

  • from_tensor_slices
  • nói lại
  • lô hàng

Mã đầy đủ để xây dựng tập dữ liệu là:

dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)

Lưu ý rằng, x là trình giữ chỗ có hình dạng sau:

  • [Không có, n_inputs]: Đặt thành Không có vì số lượng nguồn cấp hình ảnh vào mạng bằng kích thước lô.

để biết chi tiết, vui lòng tham khảo hướng dẫn về hồi quy tuyến tính.

Sau đó, bạn cần tạo trình lặp. Nếu không có dòng mã này, sẽ không có dữ liệu nào đi qua đường ống.

iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()

Bây giờ đường dẫn đã sẵn sàng, bạn có thể kiểm tra xem hình ảnh đầu tiên có giống như trước đây không (ví dụ: một người đàn ông trên ngựa).

Bạn đặt kích thước lô thành 1 vì bạn chỉ muốn cung cấp tập dữ liệu với một hình ảnh. Bạn có thể xem thứ nguyên của dữ liệu với print (sess.run (features) .shape). Nó bằng (1, 1024). 1 có nghĩa là mỗi hình ảnh chỉ có 1024 được cấp dữ liệu. Nếu kích thước lô được đặt thành hai, thì hai hình ảnh sẽ đi qua đường ống. (Không thay đổi kích thước hàng loạt. Nếu không, nó sẽ gây ra lỗi. Mỗi lần chỉ có một hình ảnh có thể chuyển đến hàm plot_image ().

## Parametersn_inputs = 32 * 32BATCH_SIZE = 1batch_size = tf.placeholder(tf.int64)# using a placeholderx = tf.placeholder(tf.float32, shape=[None,n_inputs])## Datasetdataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()## Print the imagewith tf.Session() as sess:# feed the placeholder with datasess.run(iter.initializer, feed_dict={x: horse_x,batch_size: BATCH_SIZE})print(sess.run(features).shape)plot_image(sess.run(features), shape=[32, 32], cmap = "Greys_r")(1, 1024)

Xây dựng mạng

Đã đến lúc xây dựng mạng lưới. Bạn sẽ đào tạo một bộ mã tự động xếp chồng lên nhau, tức là một mạng có nhiều lớp ẩn.

Mạng của bạn sẽ có một lớp đầu vào với 1024 điểm, tức là 32x32, hình dạng của hình ảnh.

Khối mã hóa sẽ có một lớp ẩn trên cùng với 300 tế bào thần kinh, một lớp trung tâm với 150 tế bào thần kinh. Khối giải mã là đối xứng với bộ mã hóa. Bạn có thể hình dung mạng trong hình dưới đây. Lưu ý rằng bạn có thể thay đổi giá trị của lớp ẩn và lớp trung tâm.

Xây dựng mạng cho Autoencoder

Việc tạo mã tự động rất giống với bất kỳ mô hình học sâu nào khác.

Bạn sẽ xây dựng mô hình theo các bước sau:

  1. Xác định các tham số
  2. Xác định các lớp
  3. Xác định kiến ​​trúc
  4. Xác định sự tối ưu hóa
  5. Chạy mô hình
  6. Đánh giá mô hình

Trong phần trước, bạn đã học cách tạo đường dẫn để cung cấp mô hình, do đó không cần tạo thêm một lần tập dữ liệu nữa. Bạn sẽ xây dựng một bộ mã tự động với bốn lớp. Bạn sử dụng khởi tạo Xavier. Đây là một kỹ thuật để đặt các trọng số ban đầu bằng với phương sai của cả đầu vào và đầu ra. Cuối cùng, bạn sử dụng chức năng kích hoạt elu. Bạn điều chỉnh hàm mất mát bằng bộ điều chỉnh L2.

Bước 1) Xác định các tham số

Bước đầu tiên ngụ ý xác định số lượng tế bào thần kinh trong mỗi lớp, tốc độ học và siêu tham số của bộ điều chỉnh.

Trước đó, bạn nhập một phần chức năng. Đó là một phương pháp tốt hơn để xác định các tham số của các lớp dày đặc. Đoạn mã dưới đây xác định các giá trị của kiến ​​trúc tự động mã hóa. Như đã liệt kê trước đây, bộ mã tự động có hai lớp, với 300 tế bào thần kinh ở lớp đầu tiên và 150 ở lớp thứ hai. Giá trị của chúng được lưu trữ trong n_hiised_1 và n_hiised_2.

Bạn cần xác định tốc độ học và siêu tham số L2. Các giá trị được lưu trữ trong learning_rate và l2_reg

from functools import partial## Encodern_hidden_1 = 300n_hidden_2 = 150 # codings## Decodern_hidden_3 = n_hidden_1n_outputs = n_inputslearning_rate = 0.01l2_reg = 0.0001

Kỹ thuật khởi tạo Xavier được gọi với đối tượng xavier_initializer từ bộ ước tính đóng góp. Trong cùng một công cụ ước tính, bạn có thể thêm bộ điều chỉnh với l2_regularizer

## Define the Xavier initializationxav_init = tf.contrib.layers.xavier_initializer()## Define the L2 regularizerl2_regularizer = tf.contrib.layers.l2_regularizer(l2_reg)

Bước 2) Xác định các lớp

Tất cả các thông số của các lớp dày đặc đã được thiết lập; bạn có thể đóng gói mọi thứ trong biến bold_layer bằng cách sử dụng một phần đối tượng. solid_layer sử dụng kích hoạt ELU, khởi tạo Xavier và chính quy hóa L2.

## Create the dense layerdense_layer = partial(tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer)

Bước 3) Xác định kiến ​​trúc

Nếu bạn nhìn vào bức tranh của kiến ​​trúc, bạn lưu ý rằng mạng xếp chồng ba lớp với một lớp đầu ra. Trong đoạn mã dưới đây, bạn kết nối các lớp thích hợp. Ví dụ: lớp đầu tiên tính toán sản phẩm dấu chấm giữa các tính năng của ma trận đầu vào và ma trận chứa 300 trọng số. Sau khi sản phẩm chấm được tính toán, đầu ra chuyển đến chức năng kích hoạt Elu. Đầu ra trở thành đầu vào của lớp tiếp theo, đó là lý do tại sao bạn sử dụng nó để tính ẩn_2, v.v. Phép nhân ma trận giống nhau cho mỗi lớp vì bạn sử dụng cùng một hàm kích hoạt. Lưu ý rằng lớp cuối cùng, đầu ra, không áp dụng chức năng kích hoạt. Nó có ý nghĩa vì đây là đầu vào được tái tạo

## Make the mat mulhidden_1 = dense_layer(features, n_hidden_1)hidden_2 = dense_layer(hidden_1, n_hidden_2)hidden_3 = dense_layer(hidden_2, n_hidden_3)outputs = dense_layer(hidden_3, n_outputs, activation=None)

Bước 4) Xác định tối ưu hóa

Bước cuối cùng là xây dựng trình tối ưu hóa. Bạn sử dụng Mean Square Error làm một hàm mất mát. Nếu bạn nhớ lại hướng dẫn về hồi quy tuyến tính, bạn biết rằng MSE được tính toán với sự khác biệt giữa đầu ra dự đoán và nhãn thực. Ở đây, nhãn là đặc điểm do mô hình cố gắng tái tạo lại đầu vào. Do đó, bạn muốn giá trị trung bình của tổng chênh lệch bình phương giữa đầu ra và đầu vào được dự đoán. Với TensorFlow, bạn có thể viết mã hàm mất mát như sau:

loss = tf.reduce_mean(tf.square(outputs - features))

Sau đó, bạn cần tối ưu hóa chức năng mất mát. Bạn sử dụng trình tối ưu hóa Adam để tính toán các độ dốc. Chức năng mục tiêu là giảm thiểu tổn thất.

## Optimizeloss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)

Một cài đặt nữa trước khi đào tạo mô hình. Bạn muốn sử dụng kích thước lô là 150, tức là, cung cấp cho đường ống với 150 hình ảnh mỗi lần lặp. Bạn cần tính toán số lần lặp lại theo cách thủ công. Điều này là nhỏ để làm:

Nếu bạn muốn truyền 150 hình ảnh mỗi lần và bạn biết có 5000 hình ảnh trong tập dữ liệu, thì số lần lặp lại bằng. Trong python, bạn có thể chạy các mã sau và đảm bảo đầu ra là 33:

BATCH_SIZE = 150### Number of batches : length dataset / batch sizen_batches = horse_x.shape[0] // BATCH_SIZEprint(n_batches)33

Bước 5) Chạy mô hình

Cuối cùng nhưng không kém phần quan trọng, đào tạo người mẫu. Bạn đang đào tạo mô hình với 100 kỷ nguyên. Nghĩa là, mô hình sẽ nhìn thấy hình ảnh gấp 100 lần so với trọng lượng được tối ưu hóa.

Bạn đã quen thuộc với các mã để đào tạo một mô hình trong Tensorflow. Sự khác biệt nhỏ là phân tích dữ liệu trước khi chạy đào tạo. Bằng cách này, mô hình đào tạo nhanh hơn.

Bạn quan tâm đến việc in lỗ sau mười kỷ nguyên để xem liệu mô hình có đang học được điều gì không (tức là mức lỗ đang giảm). Quá trình đào tạo kéo dài từ 2 đến 5 phút, tùy thuộc vào phần cứng máy của bạn.

## Set paramsn_epochs = 100## Call Saver to save the model and re-use it later during evaluationsaver = tf.train.Saver()with tf.Session() as sess:sess.run(tf.global_variables_initializer())# initialise iterator with train datasess.run(iter.initializer, feed_dict={x: horse_x,batch_size: BATCH_SIZE})print('Training… ')print(sess.run(features).shape)for epoch in range(n_epochs):for iteration in range(n_batches):sess.run(train)if epoch % 10 == 0:loss_train = loss.eval() # not shownprint("\r{}".format(epoch), "Train MSE:", loss_train)#saver.save(sess, "./my_model_all_layers.ckpt")save_path = saver.save(sess, "./model.ckpt")print("Model saved in path: %s" % save_path)Training… (150, 1024)0 Train MSE: 2934.45510 Train MSE: 1672.67620 Train MSE: 1514.70930 Train MSE: 1404.311840 Train MSE: 1425.05850 Train MSE: 1479.063160 Train MSE: 1609.525970 Train MSE: 1482.322380 Train MSE: 1445.703590 Train MSE: 1453.8597Model saved in path: ./model.ckpt

Bước 6) Đánh giá mô hình

Bây giờ bạn đã được đào tạo mô hình của mình, đã đến lúc đánh giá nó. Bạn cần nhập sert thử nghiệm từ tệp / cifar-10-batches-py /.

test_data = unpickle('./cifar-10-batches-py/test_batch')test_x = grayscale(test_data['data'])#test_labels = np.array(test_data['labels'])

LƯU Ý: Đối với máy Windows, mã trở thành test_data = unickle (r "E: \ cifar-10-batches-py \ test_batch")

Bạn có thể thử in các hình ảnh 13, đó là một con ngựa

plot_image(test_x[13], shape=[32, 32], cmap = "Greys_r")

Để đánh giá mô hình, bạn sẽ sử dụng giá trị pixel của hình ảnh này và xem liệu bộ mã hóa có thể tái tạo lại hình ảnh tương tự sau khi thu nhỏ 1024 pixel hay không. Lưu ý rằng, bạn xác định một chức năng để đánh giá mô hình trên các bức ảnh khác nhau. Mô hình chỉ hoạt động tốt hơn trên ngựa.

Hàm nhận hai đối số:

  • df: Nhập dữ liệu thử nghiệm
  • image_number: cho biết hình ảnh cần nhập

Chức năng được chia thành ba phần:

  1. Định hình lại hình ảnh theo đúng kích thước, tức là 1, 1024
  2. Nạp mô hình với hình ảnh không nhìn thấy, mã hóa / giải mã hình ảnh
  3. In hình ảnh thực và hình ảnh tái tạo
def reconstruct_image(df, image_number = 1):## Part 1: Reshape the image to the correct dimension i.e 1, 1024x_test = df[image_number]x_test_1 = x_test.reshape((1, 32*32))## Part 2: Feed the model with the unseen image, encode/decode the imagewith tf.Session() as sess:sess.run(tf.global_variables_initializer())sess.run(iter.initializer, feed_dict={x: x_test_1,batch_size: 1})## Part 3: Print the real and reconstructed image# Restore variables from disk.saver.restore(sess, "./model.ckpt")print("Model restored.")# Reconstruct imageoutputs_val = outputs.eval()print(outputs_val.shape)fig = plt.figure()# Plot realax1 = fig.add_subplot(121)plot_image(x_test_1, shape=[32, 32], cmap = "Greys_r")# Plot estimatedax2 = fig.add_subplot(122)plot_image(outputs_val, shape=[32, 32], cmap = "Greys_r")plt.tight_layout()fig = plt.gcf()

Bây giờ hàm đánh giá đã được xác định, bạn có thể có cái nhìn về số hình ảnh được tái tạo mười ba

reconstruct_image(df =test_x, image_number = 13) 
INFO:tensorflow:Restoring parameters from ./model.ckptModel restored.(1, 1024)

Tóm lược

Mục đích chính của bộ mã tự động là nén dữ liệu đầu vào, sau đó giải nén nó thành một đầu ra giống như dữ liệu gốc.

Kiến trúc của một bộ mã tự động đối xứng với một lớp trục có tên là lớp trung tâm.

Bạn có thể tạo mã tự động bằng cách sử dụng:

  • Một phần: để tạo các lớp dày đặc với cài đặt điển hình:
  • tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer
  • solid_layer (): để thực hiện phép nhân ma trận

bạn có thể xác định hàm mất mát và tối ưu hóa với:

loss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)

Chạy một phiên cuối cùng để đào tạo mô hình.