Hướng dẫn hồi quy tuyến tính với TensorFlow [Ví dụ]

Hồi quy tuyến tính là gì?

linear Regression Hồi quy tuyến tính là một phương pháp trong thống kê dùng để mô hình hóa mối quan hệ giữa hai biến số. Việc mô hình hóa này được thực hiện giữa một biến phản hồi vô hướng và một hoặc nhiều biến giải thích. Mối quan hệ với một biến giải thích được gọi là hồi quy tuyến tính đơn giản, và với nhiều hơn một biến giải thích thì được gọi là hồi quy tuyến tính đa biến.

TensorFlow cung cấp các công cụ để có toàn quyền kiểm soát việc tính toán. Việc này được thực hiện bằng API cấp thấp. Trên hết, TensorFlow được trang bị rất nhiều API để thực hiện nhiều học máy các thuật toán. Đây là API cấp cao, và TensorFlow gọi chúng là các bộ ước lượng.

• API cấp thấpXây dựng kiến ​​trúc và tối ưu hóa mô hình từ đầu. Điều này khá phức tạp đối với người mới bắt đầu.
• API cấp cao: Hãy định nghĩa thuật toán. Nó rất thân thiện với người dùng. TensorFlow cung cấp một bộ công cụ có tên là... người ước tính để xây dựng, đào tạo, đánh giá và đưa ra dự đoán.

Trong hướng dẫn này, bạn sẽ sử dụng chỉ công cụ ước tínhCác phép tính nhanh hơn và dễ thực hiện hơn. Phần đầu tiên giải thích cách sử dụng trình tối ưu hóa gradient descent để huấn luyện mô hình hồi quy tuyến tính trong TensorFlow. Trong phần thứ hai, bạn sẽ sử dụng tập dữ liệu Boston để dự đoán giá nhà bằng cách sử dụng bộ ước lượng TensorFlow.

Tải xuống Bộ dữ liệu Boston

Cách huấn luyện mô hình hồi quy tuyến tính

Trước khi bắt đầu huấn luyện mô hình, chúng ta hãy cùng xem hồi quy tuyến tính thực chất là gì.

Hãy tưởng tượng bạn có hai biến số, x và y, và nhiệm vụ của bạn là dự đoán giá trị của y khi biết giá trị của x. Nếu bạn vẽ đồ thị dữ liệu, bạn có thể thấy mối quan hệ thuận giữa biến độc lập x và biến phụ thuộc y, như biểu đồ phân tán bên dưới cho thấy.

Bạn có thể nhận thấy rằng nếu x=1, y sẽ xấp xỉ bằng 6, và nếu x=2, y sẽ vào khoảng 8.5.

Đây không phải là phương pháp chính xác lắm và dễ xảy ra sai sót, đặc biệt là với tập dữ liệu chứa hàng trăm nghìn điểm.

Hồi quy tuyến tính được đánh giá bằng một phương trình. Biến y được giải thích bởi một hoặc nhiều hiệp phương sai. Trong ví dụ của bạn, chỉ có một biến phụ thuộc. Nếu bạn phải viết phương trình này, nó sẽ là:

Với:

• là độ lệch. Tức là, nếu x=0, y=
• là trọng lượng liên quan đến x
• Đây là phần dư, hay sai số của mô hình. Nó bao gồm những gì mô hình không thể học được từ dữ liệu.

Hãy tưởng tượng bạn phù hợp với mô hình và tìm ra giải pháp sau cho:

• = 3.8
• = 2.78

Bạn có thể thay thế những số đó vào phương trình và nó sẽ trở thành:

y= 3.8 + 2.78x

Giờ đây bạn đã có một cách tốt hơn để tìm giá trị cho y. Nghĩa là, bạn có thể thay thế x bằng bất kỳ giá trị nào bạn muốn để dự đoán y. Trong hình bên dưới, chúng tôi đã thay thế x trong phương trình bằng tất cả các giá trị trong tập dữ liệu và vẽ đồ thị kết quả.

Đường màu đỏ biểu thị giá trị phù hợp, tức là giá trị của y cho mỗi giá trị của x. Bạn không cần phải nhìn thấy giá trị của x để dự đoán y; với mỗi x đều có một giá trị nằm trên đường màu đỏ. Bạn cũng có thể dự đoán cho các giá trị của x lớn hơn 2.

Nếu bạn muốn mở rộng hồi quy tuyến tính cho nhiều biến độc lập hơn, bạn có thể làm như vậy bằng cách thêm nhiều biến hơn vào mô hình. Sự khác biệt giữa phân tích truyền thống và hồi quy tuyến tính là hồi quy tuyến tính xem xét phản ứng của y đối với từng biến x được xem xét một cách độc lập.

Hãy xem một ví dụ. Giả sử bạn muốn dự đoán doanh số bán hàng của một cửa hàng kem. Tập dữ liệu chứa nhiều thông tin khác nhau như thời tiết (mưa, nắng, nhiều mây) và thông tin khách hàng (lương, giới tính, tình trạng hôn nhân).

Phương pháp phân tích truyền thống sẽ cố gắng dự đoán doanh số bằng cách, chẳng hạn, tính trung bình cho từng biến số và cố gắng ước tính doanh số cho các kịch bản khác nhau. Điều này sẽ dẫn đến những dự đoán kém chính xác và hạn chế phân tích chỉ trong kịch bản đã chọn.

Nếu bạn sử dụng hồi quy tuyến tính, bạn có thể viết phương trình này:

Thuật toán sẽ tìm ra giải pháp tối ưu nhất cho các trọng số; điều đó có nghĩa là nó sẽ cố gắng giảm thiểu chi phí, tức là sự khác biệt giữa đường hồi quy và các điểm dữ liệu.

Cách thức hoạt động của thuật toán

Sơ đồ dưới đây tóm tắt vòng lặp mà thuật toán thực hiện: chọn trọng số, dự đoán y, đo lỗi và hiệu chỉnh trọng số.

Thuật toán sẽ chọn một số ngẫu nhiên cho mỗi và và thay thế giá trị của x để có được giá trị dự đoán của y. Nếu tập dữ liệu có 100 quan sát, thuật toán sẽ tính 100 giá trị dự đoán.

Chúng tôi có thể tính toán lỗi, lưu ý Sai số của mô hình là sự khác biệt giữa giá trị dự đoán và giá trị thực tế. Sai số dương có nghĩa là mô hình đánh giá thấp hơn giá trị dự đoán của y, và sai số âm có nghĩa là mô hình đánh giá cao hơn giá trị dự đoán của y.

Mục tiêu của bạn là giảm thiểu bình phương sai số. Thuật toán tính toán giá trị trung bình của bình phương sai số. Bước này được gọi là giảm thiểu sai số. Đối với hồi quy tuyến tính, đây là bước... Lỗi bình phương trung bình, còn được gọi là MSE. Về mặt toán học, đó là:

Trong đó:

• là trọng lượng, vậy nên đề cập đến giá trị dự đoán
• y là giá trị thực
• m là số lượng quan sát

Lưu ý rằng có nghĩa là nó sử dụng phép chuyển vị của ma trận. Các là ký hiệu toán học của giá trị trung bình.

Mục tiêu là tìm ra điều tốt nhất nhằm giảm thiểu MSE.

Nếu sai số trung bình lớn, điều đó có nghĩa là mô hình hoạt động kém và trọng số không được chọn đúng. Để sửa trọng số, bạn cần sử dụng trình tối ưu hóa. Trình tối ưu hóa truyền thống được gọi là Xuống dốc.

Thuật toán gradient descent lấy đạo hàm và giảm hoặc tăng trọng số. Nếu đạo hàm dương, trọng số giảm. Nếu đạo hàm âm, trọng số tăng. Mô hình sẽ cập nhật trọng số và tính toán lại sai số. Quá trình này được lặp lại cho đến khi sai số không thay đổi nữa. Mỗi lần lặp được gọi là một chu kỳ. sự lặp lạiNgoài ra, độ dốc được nhân với tốc độ học, cho biết tốc độ của quá trình học.

Nếu tốc độ học quá nhỏ, thuật toán sẽ mất rất nhiều thời gian để hội tụ, vì nó yêu cầu nhiều lần lặp hơn. Nếu tốc độ học quá cao, thuật toán có thể không bao giờ hội tụ. Đường cong hàm mất mát bên dưới biểu diễn lỗi theo số lần lặp cho tập dữ liệu này.

Như bạn có thể thấy từ hình ảnh trên, mô hình lặp lại quá trình khoảng 20 lần trước khi tìm ra giá trị ổn định cho các trọng số, do đó đạt được sai số thấp nhất.

Lưu ý rằng sai số không bằng 0 mà ổn định ở mức khoảng 5. Điều này có nghĩa là mô hình có sai số điển hình là 5. Nếu bạn muốn giảm sai số, bạn cần bổ sung thêm thông tin vào mô hình, chẳng hạn như thêm biến số, hoặc sử dụng các phương pháp ước lượng khác.

Bạn còn nhớ phương trình đầu tiên chứ:

Các trọng số cuối cùng là 3.8 và 2.78. Video bên dưới cho thấy cách thuật toán gradient descent tối ưu hóa hàm mất mát để tìm ra các trọng số này.

Cách huấn luyện hồi quy tuyến tính với TensorFlow

Bây giờ bạn đã hiểu rõ hơn về những gì đang diễn ra phía sau, bạn đã sẵn sàng sử dụng API công cụ ước tính do TensorFlow cung cấp để huấn luyện hồi quy tuyến tính đầu tiên bằng TensorFlow.

Ghi chú phiên bản: Quy trình ước lượng được hiển thị bên dưới được viết dựa trên TensorFlow 1.x và các phiên bản 2.x đầu tiên. TensorFlow đã đánh dấu tf.estimator và tf.feature_column Các API đã bị loại bỏ hoàn toàn trong phiên bản 2.12 và Estimators đã bị loại bỏ trong phiên bản 2.16. Trên bản cài đặt hiện tại, hãy chạy đoạn mã này bên trong TensorFlow 1.15 hoặc 2.x-with-tf.compat.v1 môi trường, hoặc chuyển nó sang Keras, trong đó tf.keras.layers.Dense(1) Các lớp tiền xử lý bổ sung thay thế cho LinearRegressor và các cột đặc trưng. Các khái niệm — đặc trưng, ​​nhãn, lô, epoch, MSE và thuật toán gradient descent — vẫn được giữ nguyên.

Bạn sẽ sử dụng Bộ dữ liệu Boston, bao gồm các biến sau.

Bạn sẽ tạo ba bộ dữ liệu khác nhau:

Mục tiêu là sử dụng các đặc điểm của tập dữ liệu để dự đoán giá trị của ngôi nhà.

Trong phần thứ hai của hướng dẫn, bạn sẽ học cách sử dụng TensorFlow với ba phương pháp khác nhau để nhập dữ liệu:

• Với gấu trúc
• Với numpy
• Chỉ dành cho TensorFlow

Lưu ý rằng cả ba phương án đều cho kết quả như nhau.

Bạn sẽ học cách sử dụng API cấp cao để xây dựng, huấn luyện và đánh giá mô hình hồi quy tuyến tính TensorFlow. Nếu bạn sử dụng API cấp thấp, bạn sẽ phải tự định nghĩa thủ công các tham số sau:

• Thiếu chức năng
• Thuật toán tối ưu hóa: giảm độ dốc
• Phép nhân ma trận
• Đồ thị và tensor

Việc này tốn thời gian và phức tạp hơn đối với người mới bắt đầu.

Giải pháp Pandas

Bạn cần nhập các thư viện cần thiết để huấn luyện mô hình.

import pandas as pd
from sklearn import datasets
import tensorflow as tf
import itertools

Bước 1) Nhập dữ liệu với Gấu trúc.

Bạn định nghĩa tên các cột và lưu trữ chúng trong biến COLUMNS. Bạn có thể sử dụng pd.read_csv() để nhập dữ liệu.

COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age",
           "dis", "tax", "ptratio", "medv"]

Hãy trỏ mỗi lệnh gọi đến các tệp CSV mà bạn đã tải xuống trước đó.

training_set = pd.read_csv("E:/boston_train.csv", skipinitialspace=True,skiprows=1, names=COLUMNS)
test_set = pd.read_csv("E:/boston_test.csv", skipinitialspace=True,skiprows=1, names=COLUMNS)
prediction_set = pd.read_csv("E:/boston_predict.csv", skipinitialspace=True,skiprows=1, names=COLUMNS)

Bạn có thể in hình dạng của dữ liệu.

print(training_set.shape, test_set.shape, prediction_set.shape)

Đầu ra

(400, 10) (100, 10) (6, 10)

Lưu ý rằng nhãn, tức là biến y của bạn, đã được bao gồm trong tập dữ liệu. Vì vậy, bạn cần định nghĩa hai danh sách khác: một danh sách chỉ chứa các đặc trưng và một danh sách chỉ chứa tên của nhãn. Hai danh sách này sẽ cho trình ước lượng biết các đặc trưng trong tập dữ liệu là gì và tên cột nào là nhãn.

Nó được thực hiện với mã dưới đây.

FEATURES = ["crim", "zn", "indus", "nox", "rm",
                 "age", "dis", "tax", "ptratio"]
LABEL = "medv"

Bước 2) Chuyển đổi dữ liệu

Bạn cần chuyển đổi các biến số sang định dạng phù hợp. TensorFlow cung cấp một phương thức để chuyển đổi biến liên tục: tf.feature_column.numeric_column().

Ở bước trước, bạn đã định nghĩa một danh sách các đặc trưng mà bạn muốn đưa vào mô hình. Giờ đây, bạn có thể sử dụng danh sách này để chuyển đổi chúng thành dữ liệu số. Nếu bạn muốn loại trừ các đặc trưng khỏi mô hình của mình, hãy thoải mái xóa một hoặc nhiều biến khỏi danh sách FEATURES trước khi xây dựng feature_cols.

Lưu ý rằng bạn sẽ sử dụng một Python Sử dụng list comprehension với danh sách FEATURES để tạo một danh sách mới có tên là feature_cols. Điều này giúp bạn tránh phải viết tf.feature_column.numeric_column() đến chín lần. List comprehension là một cách nhanh hơn và gọn gàng hơn để tạo các danh sách mới.

feature_cols = [tf.feature_column.numeric_column(k) for k in FEATURES]

Bước 3) Xác định công cụ ước tính

Ở bước này, bạn cần định nghĩa bộ ước lượng. TensorFlow cung cấp sáu bộ ước lượng được xây dựng sẵn, ba bộ dành cho các tác vụ phân loại và ba bộ dành cho các tác vụ hồi quy TensorFlow:

• hồi quy
  • DNNBộ hồi quy
  • Bộ hồi quy tuyến tính
  • Bộ hồi quy DNNLinearCombined
• phân loại
  • Bộ phân loại DNN
  • Bộ phân loại tuyến tính
  • DNNBộ phân loại kết hợp tuyến tính

Trong hướng dẫn này, bạn sẽ sử dụng Bộ hồi quy tuyến tính. Để truy cập chức năng này, bạn cần sử dụng tf.estimator.

Hàm cần hai đối số:

• feature_columns: chứa các biến cần đưa vào mô hình.
• model_dir: đường dẫn để lưu trữ đồ thị, lưu các tham số mô hình, v.v.

TensorFlow sẽ tự động tạo một thư mục có tên là train trong thư mục làm việc của bạn. Bạn cần sử dụng đường dẫn này để truy cập. TenorBoardnhư được minh họa trong ví dụ hồi quy TensorFlow bên dưới.

estimator = tf.estimator.LinearRegressor(
        feature_columns=feature_cols,
        model_dir="train")

Đầu ra

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'train', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a215dc550>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

Điểm khó khăn khi sử dụng TensorFlow là cách cung cấp dữ liệu cho mô hình. TensorFlow được thiết kế để hoạt động với tính toán song song và các tập dữ liệu rất lớn. Do hạn chế về tài nguyên máy, không thể cung cấp toàn bộ dữ liệu cho mô hình cùng một lúc. Vì vậy, bạn cần cung cấp từng lô dữ liệu một. Lưu ý rằng chúng ta đang nói về các tập dữ liệu khổng lồ với hàng triệu bản ghi trở lên. Nếu bạn không thêm từng lô dữ liệu, bạn sẽ gặp lỗi bộ nhớ.

Ví dụ: nếu dữ liệu của bạn chứa 100 quan sát và bạn xác định kích thước lô là 10, điều đó có nghĩa là mô hình sẽ thấy 10 quan sát cho mỗi lần lặp (10*10).

Khi mô hình đã xem xét tất cả dữ liệu, nó sẽ hoàn thành một epoch. Một epoch xác định số lần bạn muốn mô hình xem dữ liệu. Tốt hơn hết là nên đặt bước này thành "none" và để mô hình thực hiện một số lần lặp nhất định.

Thông tin thứ hai cần bổ sung là liệu bạn có muốn xáo trộn dữ liệu trước mỗi lần lặp hay không. Trong quá trình huấn luyện, việc xáo trộn dữ liệu rất quan trọng để mô hình không học được một mẫu cụ thể nào của tập dữ liệu. Nếu mô hình học được chi tiết của mẫu cơ bản của dữ liệu, nó sẽ gặp khó khăn trong việc khái quát hóa dự đoán cho dữ liệu chưa được thấy. Điều này được gọi là hiện tượng quá khớp (overfitting). Mô hình hoạt động tốt trên dữ liệu huấn luyện nhưng không thể dự đoán chính xác cho dữ liệu chưa được thấy.

TensorFlow giúp thực hiện hai bước này một cách dễ dàng. Khi dữ liệu được đưa vào pipeline, nó biết cần bao nhiêu quan sát (batch) và liệu có cần xáo trộn dữ liệu hay không.

Để hướng dẫn TensorFlow cách cung cấp dữ liệu cho mô hình, bạn có thể sử dụng pandas_input_fn. Đối tượng này cần năm tham số:

• x: dữ liệu tính năng
• y: dữ liệu nhãn
• batch_size: lô. Theo mặc định 128
• num_epoch: số lượng epoch, mặc định là 1
• shuffle: có xáo trộn dữ liệu hay không. Mặc định là None.

Bạn cần cung cấp dữ liệu cho mô hình nhiều lần, vì vậy bạn định nghĩa một hàm để lặp lại quá trình này. Hãy gọi hàm này là get_input_fn.

def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):
         return tf.estimator.inputs.pandas_input_fn(
         x=pd.DataFrame({k: data_set[k].values for k in FEATURES}),
         y = pd.Series(data_set[LABEL].values),
         batch_size=n_batch,
         num_epochs=num_epochs,
         shuffle=shuffle)

Phương pháp thông thường để đánh giá hiệu suất của một mô hình là:

• Đào tạo mô hình
• Đánh giá mô hình trên một tập dữ liệu khác.
• Đưa ra dự đoán

Công cụ ước lượng TensorFlow cung cấp ba hàm khác nhau để thực hiện ba bước này một cách dễ dàng.

Bước 4) Đào tạo mô hình

Bạn có thể sử dụng phương thức huấn luyện estimator để huấn luyện mô hình. Phương thức huấn luyện estimator cần một hàm đầu vào (input_fn) và số bước (steps). Bạn có thể sử dụng hàm đã tạo ở trên để cung cấp dữ liệu cho mô hình. Sau đó, bạn hướng dẫn mô hình lặp lại 1000 lần. Lưu ý rằng bạn không cần chỉ định số lượng epoch; bạn cho phép mô hình lặp lại 1000 lần. Nếu bạn đặt số lượng epoch là 1, thì mô hình sẽ lặp lại bốn lần, vì có 400 bản ghi trong tập huấn luyện và kích thước batch là 128:

1. 128 hàng
2. 128 hàng
3. 128 hàng
4. 16 hàng

Do đó, sẽ dễ dàng hơn nếu đặt số lượng epoch bằng 0 và xác định số lần lặp, như được minh họa trong ví dụ phân loại TensorFlow bên dưới.

estimator.train(input_fn=get_input_fn(training_set,
                                           num_epochs=None,
                                           n_batch = 128,
                                           shuffle=False),
                                           steps=1000)

Đầu ra

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into train/model.ckpt.
INFO:tensorflow:loss = 83729.64, step = 1
INFO:tensorflow:global_step/sec: 238.616
INFO:tensorflow:loss = 13909.657, step = 101 (0.420 sec)
INFO:tensorflow:global_step/sec: 314.293
INFO:tensorflow:loss = 12881.449, step = 201 (0.320 sec)
INFO:tensorflow:global_step/sec: 303.863
INFO:tensorflow:loss = 12391.541, step = 301 (0.327 sec)
INFO:tensorflow:global_step/sec: 308.782
INFO:tensorflow:loss = 12050.5625, step = 401 (0.326 sec)
INFO:tensorflow:global_step/sec: 244.969
INFO:tensorflow:loss = 11766.134, step = 501 (0.407 sec)
INFO:tensorflow:global_step/sec: 155.966
INFO:tensorflow:loss = 11509.922, step = 601 (0.641 sec)
INFO:tensorflow:global_step/sec: 263.256
INFO:tensorflow:loss = 11272.889, step = 701 (0.379 sec)
INFO:tensorflow:global_step/sec: 254.112
INFO:tensorflow:loss = 11051.9795, step = 801 (0.396 sec)
INFO:tensorflow:global_step/sec: 292.405
INFO:tensorflow:loss = 10845.855, step = 901 (0.341 sec)
INFO:tensorflow:Saving checkpoints for 1000 into train/model.ckpt.
INFO:tensorflow:Loss for final step: 5925.9873.

Bạn có thể kiểm tra TensorBoard bằng lệnh sau:

activate hello-tf
# For MacOS
tensorboard --logdir=./train
# For Windows
tensorboard --logdir=train

Bước 5) Đánh giá mô hình của bạn

Bạn có thể đánh giá mức độ phù hợp của mô hình của mình trên tập kiểm tra bằng mã bên dưới:

ev = estimator.evaluate(
          input_fn=get_input_fn(test_set,
          num_epochs=1,
          n_batch = 128,
          shuffle=False))

Đầu ra

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-05-13-01:43:13
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-05-13-01:43:13
INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896

Bạn có thể in phần lỗ bằng mã bên dưới:

loss_score = ev["loss"]
print("Loss: {0:f}".format(loss_score))

Đầu ra

Loss: 3215.895996

Mô hình có mức lỗ là 3215. Bạn có thể kiểm tra số liệu thống kê tóm tắt để hình dung mức độ sai số lớn đến mức nào.

training_set['medv'].describe()

Đầu ra

count    400.000000
mean      22.625500
std        9.572593
min        5.000000
25%       16.600000
50%       21.400000
75%       25.025000
max       50.000000
Name: medv, dtype: float64

Từ số liệu thống kê tóm tắt ở trên, bạn biết rằng giá nhà trung bình là 22 nghìn đô la, với giá thấp nhất là 5 nghìn đô la và giá cao nhất là 50 nghìn đô la. Vì mức lỗ được báo cáo là sai số bình phương trung bình, nên sai số điển hình trong đơn vị gốc xấp xỉ căn bậc hai của 32.16, tức là khoảng 5.7 nghìn đô la.

Bước 6) Đưa ra dự đoán

Cuối cùng, bạn có thể sử dụng phương thức dự đoán của TensorFlow để ước tính giá trị của sáu ngôi nhà ở Boston.

y = estimator.predict(
         input_fn=get_input_fn(prediction_set,
         num_epochs=1,
         n_batch = 128,
         shuffle=False))

Để in ra các giá trị ước tính, bạn có thể sử dụng đoạn mã này:

predictions = list(p["predictions"] for p in itertools.islice(y, 6))
print("Predictions: {}".format(str(predictions)))

Đầu ra

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
Predictions: [array([32.297546], dtype=float32), array([18.96125], dtype=float32), array([27.270979], dtype=float32), array([29.299236], dtype=float32), array([16.436684], dtype=float32), array([21.460876], dtype=float32)]

Mô hình dự báo các giá trị sau:

Lưu ý rằng chúng ta không biết giá trị thực sự của sáu ngôi nhà này. Trong bài hướng dẫn về học sâu, bạn sẽ cố gắng đánh bại mô hình tuyến tính.

Giải pháp NumPy

Phần này giải thích cách huấn luyện mô hình bằng cách sử dụng trình ước lượng NumPy để cung cấp dữ liệu. Phương pháp này tương tự, ngoại trừ việc bạn sẽ sử dụng trình ước lượng numpy_input_fn.

Đọc ba tệp CSV tương tự, nhưng chỉ giữ lại các mảng NumPy thô có đuôi .values.

training_set_n = pd.read_csv("E:/boston_train.csv").values
test_set_n = pd.read_csv("E:/boston_test.csv").values
prediction_set_n = pd.read_csv("E:/boston_predict.csv").values

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

Trước hết, bạn cần phân biệt các biến đặc trưng với nhãn. Bạn cần thực hiện điều này cho cả dữ liệu huấn luyện và dữ liệu đánh giá. Việc định nghĩa một hàm để chia dữ liệu sẽ nhanh hơn.

def prepare_data(df):
        X_train = df[:, :-3]
        y_train = df[:,-3]
        return X_train, y_train

Bạn có thể sử dụng hàm này để tách nhãn khỏi các đặc trưng của tập dữ liệu huấn luyện và đánh giá.

X_train, y_train = prepare_data(training_set_n)
X_test, y_test = prepare_data(test_set_n)

Bạn cần loại bỏ cột cuối cùng của tập dữ liệu dự đoán vì nó chỉ chứa toàn giá trị NaN.

x_predict = prediction_set_n[:, :-2]

Xác nhận hình dạng của mảng. Lưu ý rằng nhãn không được có chiều thứ hai, có nghĩa là (400,).

print(X_train.shape, y_train.shape, x_predict.shape)

Đầu ra

(400, 9) (400,) (6, 9)

Bạn có thể xây dựng các cột đặc trưng như sau:

feature_columns = [      tf.feature_column.numeric_column('x', shape=X_train.shape[1:])]

Công cụ ước lượng được định nghĩa như trước: bạn chỉ định các cột đặc trưng và nơi lưu đồ thị.

estimator = tf.estimator.LinearRegressor(
         feature_columns=feature_columns,
         model_dir="train1")

Đầu ra

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'train1', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a218d8f28>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

Bạn có thể sử dụng trình ước lượng NumPy để cung cấp dữ liệu cho mô hình và sau đó huấn luyện mô hình. Lưu ý rằng chúng ta đã định nghĩa hàm input_fn trước đó để dễ đọc hơn.

# Train the estimator
train_input = tf.estimator.inputs.numpy_input_fn(
           x={"x": X_train},
           y=y_train,
           batch_size=128,
           shuffle=False,
           num_epochs=None)
estimator.train(input_fn = train_input,steps=5000)

Đầu ra

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into train1/model.ckpt.
INFO:tensorflow:loss = 83729.64, step = 1
INFO:tensorflow:global_step/sec: 490.057
INFO:tensorflow:loss = 13909.656, step = 101 (0.206 sec)
INFO:tensorflow:global_step/sec: 788.986
INFO:tensorflow:loss = 12881.45, step = 201 (0.126 sec)
INFO:tensorflow:global_step/sec: 736.339
INFO:tensorflow:loss = 12391.541, step = 301 (0.136 sec)
INFO:tensorflow:global_step/sec: 383.305
INFO:tensorflow:loss = 12050.561, step = 401 (0.260 sec)
INFO:tensorflow:global_step/sec: 859.832
INFO:tensorflow:loss = 11766.133, step = 501 (0.117 sec)
INFO:tensorflow:global_step/sec: 804.394
INFO:tensorflow:loss = 11509.918, step = 601 (0.125 sec)
INFO:tensorflow:global_step/sec: 753.059
INFO:tensorflow:loss = 11272.891, step = 701 (0.134 sec)
INFO:tensorflow:global_step/sec: 402.165
INFO:tensorflow:loss = 11051.979, step = 801 (0.248 sec)
INFO:tensorflow:global_step/sec: 344.022
INFO:tensorflow:loss = 10845.854, step = 901 (0.288 sec)
INFO:tensorflow:Saving checkpoints for 1000 into train1/model.ckpt.
INFO:tensorflow:Loss for final step: 5925.985.
Out[23]:
<tensorflow.python.estimator.canned.linear.LinearRegressor at 0x1a1b6ea860>

Bạn lặp lại bước tương tự với một hàm đầu vào khác để đánh giá mô hình của mình.

eval_input = tf.estimator.inputs.numpy_input_fn(
       x={"x": X_test},
       y=y_test,
       shuffle=False,
       batch_size=128,
       num_epochs=1)
   estimator.evaluate(eval_input,steps=None)

Đầu ra

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-05-13-01:44:00
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-05-13-01:44:00
INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.158947, global_step = 1000, loss = 3215.8945
Out[24]:
{'average_loss': 32.158947, 'global_step': 1000, 'loss': 3215.8945}

Cuối cùng, bạn có thể tính toán dự đoán. Kết quả sẽ tương tự như kết quả của Pandas.

test_input = tf.estimator.inputs.numpy_input_fn(
        x={"x": x_predict},
        batch_size=128,
        num_epochs=1,
        shuffle=False)
        y = estimator.predict(test_input)

predictions = list(p["predictions"] for p in itertools.islice(y, 6))
print("Predictions: {}".format(str(predictions)))

Đầu ra

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
Predictions: [array([32.297546], dtype=float32), array([18.961248], dtype=float32), array([27.270979], dtype=float32), array([29.299242], dtype=float32), array([16.43668], dtype=float32), array([21.460878], dtype=float32)]

Giải pháp TensorFlow

Phần cuối cùng dành riêng cho một điều thuần túy. TensorFlow Giải pháp. Phương pháp này phức tạp hơn một chút so với hai phương pháp kia.

Lưu ý rằng nếu bạn sử dụng Jupyter máy tính xách tayBạn cần khởi động lại và xóa sạch nhân hệ thống để chạy phiên này.

TensorFlow đã xây dựng một công cụ tuyệt vời để truyền dữ liệu vào quy trình xử lý. Trong phần này, bạn sẽ tự xây dựng hàm input_fn.

Bước 1) Xác định đường dẫn và định dạng của dữ liệu

Trước hết, bạn khai báo hai biến với đường dẫn đến các tệp CSV. Lưu ý rằng bạn có hai tệp, một tệp dành cho tập dữ liệu huấn luyện và một tệp dành cho tập dữ liệu kiểm tra.

import tensorflow as tf

df_train = "E:/boston_train.csv"

df_eval = "E:/boston_test.csv"

Tiếp theo, bạn cần xác định các cột muốn sử dụng từ tệp CSV. Chúng ta sẽ sử dụng tất cả các cột. Sau đó, bạn cần khai báo kiểu dữ liệu cho từng biến.

Biến float được định nghĩa bởi [0.]

COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age",
                "dis", "tax", "ptratio", "medv"]
RECORDS_ALL = [[0.0], [0.0], [0.0], [0.0],[0.0],[0.0],[0.0],[0.0],[0.0],[0.0]]

Bước 2) Xác định hàm input_fn

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

1. Nhập dữ liệu
2. Tạo trình vòng lặp
3. Tiêu thụ dữ liệu

Dưới đây là đoạn mã tổng quát để định nghĩa hàm. Đoạn mã sẽ được giải thích chi tiết hơn ở phần sau.

def input_fn(data_file, batch_size, num_epoch = None):
       # Step 1
          def parse_csv(value):
          columns = tf.decode_csv(value, record_defaults= RECORDS_ALL)
          features = dict(zip(COLUMNS, columns))
          #labels = features.pop('median_house_value')
          labels =  features.pop('medv')
          return features, labels

          # Extract lines from input files using the Dataset API.
          dataset = (tf.data.TextLineDataset(data_file) # Read text file
          .skip(1) # Skip header row
          .map(parse_csv))

          dataset = dataset.repeat(num_epoch)
          dataset = dataset.batch(batch_size)
          # Step 3
          iterator = dataset.make_one_shot_iterator()
          features, labels = iterator.get_next()
          return features, labels

Nhập dữ liệu

Đối với tệp CSV, phương thức dataset đọc từng dòng một. Để xây dựng dataset, bạn cần sử dụng đối tượng. TextLineTập dữ liệu. Tập dữ liệu của bạn có tiêu đề, vì vậy bạn cần sử dụng skip(1) để bỏ qua dòng đầu tiên. Tại thời điểm này, bạn chỉ đọc dữ liệu và loại trừ tiêu đề trong quy trình. Để đưa vào mô hình, bạn cần tách các đặc trưng khỏi nhãn. Phương thức được sử dụng để áp dụng bất kỳ phép biến đổi nào cho dữ liệu là map.

Phương pháp này gọi một hàm mà bạn sẽ tạo ra để hướng dẫn cách chuyển đổi dữ liệu. Nói tóm lại, bạn cần truyền dữ liệu vào hàm đó. TextLineĐối tượng tập dữ liệu, loại bỏ phần tiêu đề và áp dụng phép biến đổi được hướng dẫn bởi một hàm.

Code giải thích

• tf.data.TextLineTập dữ liệu (data_file): dòng này đọc tệp CSV
• .skip(1): bỏ qua phần tiêu đề
• .map(parse_csv)): phân tích các bản ghi thành các tensor

Bạn cần định nghĩa một hàm để hướng dẫn đối tượng bản đồ. Bạn có thể gọi hàm này là parse_csv.

Hàm này phân tích tệp CSV bằng phương thức tf.decode_csv và khai báo các đặc trưng và nhãn. Các đặc trưng có thể được khai báo dưới dạng từ điển hoặc bộ dữ liệu. Bạn sử dụng phương thức từ điển vì nó thuận tiện hơn.

Code giải thích

• tf.decode_csv(value, record_defaults= RECORDS_ALL): phương thức giải mã_csv sử dụng đầu ra của TextLineTập dữ liệu để đọc tệp CSV. Tham số `record_defaults` hướng dẫn TensorFlow về các kiểu dữ liệu của cột. Trong TensorFlow 2.x, ký hiệu này nằm ở `tf.io.decode_csv`.
• dict(zip(COLUMNS, columns)): điền vào từ điển tất cả các cột ví dụtracted trong quá trình xử lý dữ liệu này
• features.pop('medv'): loại trừ biến mục tiêu khỏi các biến đặc trưng và tạo biến nhãn.

Tập dữ liệu cần thêm các phần tử để liên tục cung cấp dữ liệu cho các tensor. Cụ thể, bạn cần thêm phương thức `repeat` để cho phép tập dữ liệu tiếp tục cung cấp dữ liệu cho mô hình vô thời hạn. Nếu bạn không thêm phương thức này, mô hình sẽ chỉ lặp lại một lần và sau đó báo lỗi vì không còn dữ liệu nào được cung cấp vào quy trình.

Sau đó, bạn có thể kiểm soát kích thước lô bằng phương pháp batch. Điều này có nghĩa là bạn cho tập dữ liệu biết bạn muốn truyền bao nhiêu dữ liệu vào quy trình xử lý trong mỗi lần lặp. Nếu bạn đặt kích thước lô lớn, mô hình sẽ chạy chậm.

Bước 3) Tạo trình vòng lặp

Bây giờ bạn đã sẵn sàng cho bước thứ hai: tạo một trình vòng lặp để trả về các phần tử trong tập dữ liệu.

Cách đơn giản nhất để tạo toán tử là sử dụng phương thức make_one_shot_iterator.

Sau đó, bạn có thể tạo các tính năng và nhãn từ trình vòng lặp.

Bước 4) Tiêu thụ dữ liệu

Bạn có thể kiểm tra điều gì xảy ra với hàm input_fn. Bạn cần gọi hàm này trong một phiên để xử lý dữ liệu. Bạn hãy thử với kích thước lô bằng 1.

Lưu ý rằng nó in các tính năng dưới dạng từ điển và nhãn dưới dạng mảng.

Nó sẽ hiển thị dòng đầu tiên của tệp CSV. Bạn có thể thử chạy đoạn mã này nhiều lần với các kích thước lô khác nhau.

next_batch = input_fn(df_train, batch_size = 1, num_epoch = None)
with tf.Session() as sess:
     first_batch  = sess.run(next_batch)
     print(first_batch)

Đầu ra

({'crim': array([2.3004], dtype=float32), 'zn': array([0.], dtype=float32), 'indus': array([19.58], dtype=float32), 'nox': array([0.605], dtype=float32), 'rm': array([6.319], dtype=float32), 'age': array([96.1], dtype=float32), 'dis': array([2.1], dtype=float32), 'tax': array([403.], dtype=float32), 'ptratio': array([14.7], dtype=float32)}, array([23.8], dtype=float32))

Bước 5) Xác định cột tính năng

Bạn cần định nghĩa các cột số như sau:

X1= tf.feature_column.numeric_column('crim')
X2= tf.feature_column.numeric_column('zn')
X3= tf.feature_column.numeric_column('indus')
X4= tf.feature_column.numeric_column('nox')
X5= tf.feature_column.numeric_column('rm')
X6= tf.feature_column.numeric_column('age')
X7= tf.feature_column.numeric_column('dis')
X8= tf.feature_column.numeric_column('tax')
X9= tf.feature_column.numeric_column('ptratio')

Lưu ý rằng bạn cần kết hợp tất cả các biến trong một nhóm.

base_columns = [X1, X2, X3,X4, X5, X6,X7, X8, X9]

Bước 6) Xây dựng mô hình

Bạn có thể huấn luyện mô hình bằng công cụ ước tính LinearRegressor.

model = tf.estimator.LinearRegressor(feature_columns=base_columns, model_dir='train3')

Đầu ra

INFO:tensorflow:Using default config. INFO:tensorflow:Using config: {'_model_dir': 'train3', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1820a010f0>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

Bạn cần phải sử dụng một hàm lambda Để cho phép bạn viết các đối số cho hàm input_fn. Nếu bạn không sử dụng hàm lambda, bạn không thể huấn luyện mô hình.

# Train the estimator
model.train(steps =1000,
          input_fn= lambda : input_fn(df_train,batch_size=128, num_epoch = None))

Đầu ra

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into train3/model.ckpt.
INFO:tensorflow:loss = 83729.64, step = 1
INFO:tensorflow:global_step/sec: 72.5646
INFO:tensorflow:loss = 13909.657, step = 101 (1.380 sec)
INFO:tensorflow:global_step/sec: 101.355
INFO:tensorflow:loss = 12881.449, step = 201 (0.986 sec)
INFO:tensorflow:global_step/sec: 109.293
INFO:tensorflow:loss = 12391.541, step = 301 (0.915 sec)
INFO:tensorflow:global_step/sec: 102.235
INFO:tensorflow:loss = 12050.5625, step = 401 (0.978 sec)
INFO:tensorflow:global_step/sec: 104.656
INFO:tensorflow:loss = 11766.134, step = 501 (0.956 sec)
INFO:tensorflow:global_step/sec: 106.697
INFO:tensorflow:loss = 11509.922, step = 601 (0.938 sec)
INFO:tensorflow:global_step/sec: 118.454
INFO:tensorflow:loss = 11272.889, step = 701 (0.844 sec)
INFO:tensorflow:global_step/sec: 114.947
INFO:tensorflow:loss = 11051.9795, step = 801 (0.870 sec)
INFO:tensorflow:global_step/sec: 111.484
INFO:tensorflow:loss = 10845.855, step = 901 (0.897 sec)
INFO:tensorflow:Saving checkpoints for 1000 into train3/model.ckpt.
INFO:tensorflow:Loss for final step: 5925.9873.
Out[8]:
<tensorflow.python.estimator.canned.linear.LinearRegressor at 0x18225eb8d0>

Bạn có thể đánh giá mức độ phù hợp của mô hình của mình trên tập kiểm tra bằng mã bên dưới:

results = model.evaluate(steps =None,input_fn=lambda: input_fn(df_eval, batch_size =128, num_epoch = 1))
for key in results:
print("   {}, was: {}".format(key, results[key]))

Đầu ra

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-05-13-02:06:02
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-05-13-02:06:02
INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896
   average_loss, was: 32.158958435058594
   loss, was: 3215.89599609375
   global_step, was: 1000

Bước cuối cùng là dự đoán giá trị mục tiêu dựa trên giá trị của ma trận đặc trưng. Bạn có thể viết một từ điển với các giá trị mà bạn muốn dự đoán. Mô hình của bạn có chín đặc trưng, ​​vì vậy bạn cần cung cấp giá trị cho mỗi đặc trưng. Mô hình sẽ đưa ra dự đoán cho từng đặc trưng đó.

Trong đoạn mã bên dưới, bạn sẽ viết các giá trị của từng thuộc tính có trong tệp CSV df_predict.

Bạn cần viết một hàm input_fn mới vì tập dữ liệu không có nhãn. Bạn có thể sử dụng API from_tensors từ đối tượng Dataset.

prediction_input = {
          'crim': [0.03359,5.09017,0.12650,0.05515,8.15174,0.24522],
          'zn': [75.0,0.0,25.0,33.0,0.0,0.0],
          'indus': [2.95,18.10,5.13,2.18,18.10,9.90],
          'nox': [0.428,0.713,0.453,0.472,0.700,0.544],
          'rm': [7.024,6.297,6.762,7.236,5.390,5.782],
          'age': [15.8,91.8,43.4,41.1,98.9,71.7],
          'dis': [5.4011,2.3682,7.9809,4.0220,1.7281,4.0317],
          'tax': [252,666,284,222,666,304],
          'ptratio': [18.3,20.2,19.7,18.4,20.2,18.4]
     }
     def test_input_fn():
     dataset = tf.data.Dataset.from_tensors(prediction_input)
     return dataset

     # Predict all our prediction_input
     pred_results = model.predict(input_fn=test_input_fn)

Cuối cùng, bạn in ra các dự đoán.

for pred in enumerate(pred_results):
print(pred)

Đầu ra

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
(0, {'predictions': array([32.297546], dtype=float32)})
(1, {'predictions': array([18.96125], dtype=float32)})
(2, {'predictions': array([27.270979], dtype=float32)})
(3, {'predictions': array([29.299236], dtype=float32)})
(4, {'predictions': array([16.436684], dtype=float32)})
(5, {'predictions': array([21.460876], dtype=float32)})

INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train3/model.ckpt-5000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. (0, {'predictions': array([35.60663], dtype=float32)}) (1, {'predictions': array([22.298521], dtype=float32)}) (2, {'predictions': array([25.74533], dtype=float32)}) (3, {'predictions': array([35.126694], dtype=float32)}) (4, {'predictions': array([17.94416], dtype=float32)}) (5, {'predictions': array([22.606628], dtype=float32)})

Cả ba pipeline đều trả về sáu dự đoán giống nhau, điều này khẳng định rằng việc lựa chọn giữa Pandas, NumPy và bộ dữ liệu TensorFlow gốc chỉ là vấn đề tiện lợi chứ không phải độ chính xác.

Câu Hỏi Thường Gặp