Logo Zephyrnet

Tiếp cận hồi quy với mạng thần kinh bằng cách sử dụng Tensorflow

Ngày:

Bài báo này đã được xuất bản như một phần của Blogathon Khoa học Dữ liệu.

Giới thiệu

Mọi kỹ thuật học máy có giám sát về cơ bản đều giải quyết được các vấn đề về phân loại hoặc hồi quy. Phân loại là một loại kỹ thuật mà chúng ta phân loại kết quả thành các loại riêng biệt mà phạm vi của chúng thường là hữu hạn. Trong khi đó, kỹ thuật hồi quy liên quan đến việc dự đoán một số thực có phạm vi là vô hạn. Một số ví dụ về hồi quy là dự đoán giá của một ngôi nhà với số phòng ngủ và số tầng trong đó hoặc dự đoán xếp hạng sản phẩm cho các thông số kỹ thuật của sản phẩm, v.v.

Mạng nơron là một trong những thuật toán quan trọng nhất có ứng dụng sâu sắc trong lĩnh vực xử lý ngôn ngữ tự nhiên và thị giác máy tính. Bây giờ chúng ta hãy áp dụng các mạng nơ-ron này trên dữ liệu dạng bảng cho một nhiệm vụ hồi quy. Chúng tôi sẽ sử dụng thư viện học sâu Tensorflow và Keras để xây dựng và đào tạo mạng nơ-ron của mình.

Băt đâu nao…

Hồi quy với mạng thần kinh
Tham khảo I

Giới thiệu về Dataset

Tập dữ liệu chúng tôi đang sử dụng để đào tạo mô hình của mình là MPG tự động tập dữ liệu. Bộ dữ liệu này bao gồm các tính năng khác nhau của các loại ô tô thường được sử dụng trong những năm 1980 và 90. Điều này bao gồm các thuộc tính như số lượng xi-lanh, mã lực, trọng lượng của ô tô, v.v. Sử dụng các tính năng này, chúng ta sẽ dự đoán số dặm trên mỗi gallon hoặc số dặm của ô tô. Do đó, làm cho nó trở thành một nhiệm vụ hồi quy nhiều biến thể. Có thể tìm thêm thông tin về tập dữ liệu Ở đây.

Bắt đầu

Hãy bắt đầu bằng cách nhập các thư viện được yêu cầu và tải xuống tập dữ liệu.

nhập gấu trúc dưới dạng pd nhập matplotlib.pyplot dưới dạng plt nhập tensorflow dưới dạng tf từ tensorflow nhập keras từ tensorflow.keras nhập các lớp từ tensorflow.keras nhập Tuần tự từ tensorflow.keras nhập tối ưu hóa

Bây giờ chúng ta hãy tải xuống và phân tích cú pháp tập dữ liệu bằng cách sử dụng gấu trúc thành một khung dữ liệu.

url = "http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data" column_names = ["MPG", "Xi lanh", "Displacement", "Mã lực "," Trọng lượng "," Gia tốc "," Năm Model "," Xuất xứ "] df = pd.read_csv (url, names = column_names, sep =" ", comment =" t ", na_values ​​="? ", Skipinitialspace = Thật)

Chúng tôi đã trực tiếp tải xuống tập dữ liệu bằng phương thức pandas read_csv và phân tích cú pháp nó thành một khung dữ liệu. Chúng ta có thể kiểm tra nội dung của khung dữ liệu để biết thêm chi tiết.

df.head ()

Bây giờ, hãy xử lý trước khung dữ liệu này để giúp mô hình học sâu của chúng ta hiểu dễ dàng hơn. Trước đó, bạn nên tạo một bản sao của tập dữ liệu gốc và sau đó làm việc trên nó.

# Tạo bản sao để xử lý thêm tập dữ liệu = df.copy () # Lấy một số dữ liệu cơ bản về in tập dữ liệu (len (dataset))

Xử lý dữ liệu

Bây giờ hãy xử lý trước tập dữ liệu của chúng tôi. Đầu tiên, hãy kiểm tra các giá trị null vì điều quan trọng là phải xử lý tất cả các giá trị null trước khi cung cấp dữ liệu vào mô hình của chúng tôi (Nếu dữ liệu bao gồm các giá trị null, mô hình sẽ không thể học dẫn đến kết quả rỗng).

# Kiểm tra giá trị null dataset.isna (). Sum ()

Vì chúng tôi gặp một số giá trị rỗng trong cột 'Mã lực', chúng tôi có thể xử lý chúng dễ dàng bằng cách sử dụng thư viện Pandas. Chúng tôi thường có thể loại bỏ tất cả các giá trị null bằng cách sử dụng dropna () hoặc cũng điền các giá trị null đó với một số giá trị như giá trị trung bình của toàn bộ cột, v.v. Hãy sử dụng fillna () để điền vào các giá trị null.

# Có một số giá trị na. Chúng ta có thể điền hoặc xóa các hàng đó. tập dữ liệu ['Mã lực']. fillna (tập dữ liệu ['Mã lực']. mean (), inplace = True) dataset.isna (). sum ()

Bây giờ chúng ta có thể thấy rằng không có giá trị null nào hiện diện trong bất kỳ cột nào. Theo tập dữ liệu, cột 'Nguồn gốc' không phải là số mà là phân loại, tức là mỗi số đại diện cho mỗi quốc gia. Vì vậy, hãy mã hóa cột này bằng cách sử dụng gấu trúc get_dummies () phương pháp.

dataset ['Origin']. value_counts () dataset ['Origin'] = dataset ['Origin']. map ({1: 'USA', 2: 'Europe', 3: 'Japan'}) dataset = pd. get_dummies (tập dữ liệu, cột = ['Nguồn gốc'], prefix = '', prefix_sep = '') dataset.head ()

Đối với kết quả trên, chúng ta có thể thấy rằng cột 'Xuất xứ' được thay thế bằng 3 cột có tên các quốc gia với 1 hoặc 0 đại diện cho quốc gia xuất xứ.

Bây giờ, hãy chia tập dữ liệu thành tập huấn luyện và thử nghiệm / xác nhận. Điều này rất hữu ích để kiểm tra tính hiệu quả của mô hình, tức là mô hình tổng quát tốt như thế nào trên dữ liệu không nhìn thấy.

# Tách Tập dữ liệu và tạo tập huấn luyện và thử nghiệm train_dataset = dataset.sample (frac = 0.8, random_state = 0) test_dataset = dataset.drop (train_dataset.index) ################ ########################################### # Các nhãn và tính năng riêng biệt train_features = train_dataset.drop (["MPG"], axis = 1) test_features = test_dataset.drop (["MPG"], axis = 1) train_labels = train_dataset ["MPG"] test_labels = test_dataset ["MPG"]

Chúng tôi có thể kiểm tra một số thống kê cơ bản về dữ liệu bằng cách sử dụng gấu trúc diễn tả() chức năng.

# Hãy kiểm tra một số dữ liệu cơ bản về tập dữ liệu train_dataset.describe (). Transpose ()

Bây giờ chúng ta có thể tiến hành bước tiền xử lý dữ liệu tiếp theo: Chuẩn hóa.

Chuẩn hóa dữ liệu là một trong những bước tiền xử lý cơ bản sẽ chuyển đổi dữ liệu sang định dạng mà mô hình có thể dễ dàng xử lý. Trong bước này, chúng tôi chia tỷ lệ dữ liệu sao cho giá trị trung bình bằng 0 và độ lệch chuẩn là 1. Chúng tôi sẽ sử dụng thư viện học khoa học sci-kit để làm điều tương tự.

# Nhưng chúng ta cũng có thể áp dụng chuẩn hóa bằng sklearn. từ sklearn.preprocessing nhập StandardScaler feature_scaler = StandardScaler () label_scaler = StandardScaler () #################################### ####################### # Fit on Training Data feature_scaler.fit (train_features.values) label_scaler.fit (train_labels.values.reshape (-1, 1) ) ##################################################### ####### # Chuyển đổi cả dữ liệu đào tạo và kiểm tra train_features = feature_scaler.transform (train_features.values) test_features = feature_scaler.transform (test_features.values) train_labels = label_scaler.transform (train_labels.values.reshape (-1, 1 )) test_labels = label_scaler.transform (test_labels.values.reshape (-1, 1))

Chúng tôi thực hiện khớp và biến đổi một cách riêng biệt vì khớp sẽ học cách biểu diễn dữ liệu của dữ liệu đầu vào và phép biến đổi sẽ áp dụng cách biểu diễn đã học. Bằng cách này, chúng tôi sẽ có thể tránh nhìn vào biểu diễn / thống kê của dữ liệu thử nghiệm.

Bây giờ chúng ta hãy đi vào phần thú vị nhất của quá trình: Xây dựng mạng nơ-ron của chúng tôi.

Tạo mô hình

Hãy tạo mô hình của chúng tôi bằng cách sử dụng Keras Tuần tự API. Chúng ta có thể xếp chồng các lớp cần thiết vào mô hình tuần tự và sau đó xác định kiến ​​trúc yêu cầu. Bây giờ, hãy tạo một mạng nơ-ron dày đặc được kết nối đầy đủ cơ bản cho dữ liệu của chúng ta.

# Bây giờ chúng ta hãy tạo Mạng thần kinh sâu để đào tạo mô hình hồi quy trên dữ liệu của chúng ta. model = Sequential ([lớp.Dense (32, kích hoạt = 'relu'), lớp.Dense (64, kích hoạt = 'relu'), lớp.Dense (1)])

Chúng tôi đã xác định mô hình tuần tự bằng cách thêm 2 lớp dày đặc với 32 và 64 đơn vị tương ứng, cả hai đều sử dụng Đơn vị tuyến tính chỉnh lưu chức năng kích hoạt tức là Tiếp sức. Cuối cùng, chúng tôi đang thêm một lớp dày đặc với 1 nơ-ron đại diện cho kích thước đầu ra, tức là một số duy nhất. Bây giờ chúng ta hãy biên dịch mô hình bằng cách chỉ định hàm mất mát và trình tối ưu hóa.

model.compile (tối ưu hóa = "RMSProp", loss = "mean_squared_error")

Đối với mô hình của chúng tôi, chúng tôi đang sử dụng RMSProp trình tối ưu hóa và có nghĩa là lỗi bình phương thiếu chức năng. Đây là những thông số quan trọng đối với mô hình của chúng tôi vì trình tối ưu hóa xác định cách mô hình của chúng tôi sẽ được cải thiện và mất mát xác định những gì sẽ được cải thiện.

Bạn nên thử cập nhật / chơi với mô hình trên bằng cách sử dụng các lớp khác nhau hoặc thay đổi bộ tối ưu hóa và chức năng mất mát và quan sát hiệu suất mô hình cải thiện hoặc xấu đi như thế nào.

Bây giờ chúng tôi đã sẵn sàng để đào tạo mô hình !!

Đào tạo và Đánh giá Mô hình

Bây giờ, hãy đào tạo mô hình của chúng tôi bằng cách chỉ định các tính năng và nhãn đào tạo cho 100 kỷ nguyên. Chúng tôi cũng có thể chuyển dữ liệu xác thực để kiểm tra định kỳ mô hình của chúng tôi đang hoạt động như thế nào.

# Bây giờ, hãy huấn luyện lịch sử mô hình = model.fit (epochs = 100, x = train_features, y = train_labels, validation_data = (test_features, test_labels), verbose = 0)

Vì chúng tôi đã chỉ định verbose = 0, chúng tôi sẽ không nhận được bất kỳ nhật ký đào tạo mô hình nào cho mọi kỷ nguyên. Chúng tôi có thể sử dụng lịch sử mô hình để vẽ biểu đồ mô hình của chúng tôi đã hoạt động như thế nào trong quá trình đào tạo. Hãy xác định một hàm cho tương tự.

# Hàm lập biểu đồ tổn thất def plot_loss (history): plt.plot (history.history ['loss'], label = 'loss') plt.plot (history.history ['val_loss'], label = 'val_loss') plt .ylim ([0,10]) plt.xlabel ('Kỷ nguyên') plt.ylabel ('Lỗi (Mất)') plt.legend () plt.grid (Đúng) ########### ################################################lot_loss (lịch sử)
Hồi quy với mạng thần kinh
Lô mất mát

Bây giờ chúng ta có thể thấy rằng mô hình của chúng tôi đã có thể đạt được ít tổn thất nhất trong quá trình đào tạo. Điều này là do các lớp được kết nối đầy đủ mà qua đó mô hình của chúng tôi có thể dễ dàng phát hiện các mẫu trong tập dữ liệu.

Bây giờ cuối cùng hãy đánh giá mô hình trên tập dữ liệu thử nghiệm của chúng tôi.

# Đánh giá mô hình trên mô hình tập dữ liệu thử nghiệm. Đánh giá (test_features, test_labels)

Mô hình hoạt động tốt trên tập dữ liệu thử nghiệm! Chúng ta có thể lưu mô hình này và sử dụng mô hình đã lưu để dự đoán một số dữ liệu khác.

# Lưu mô hình model.save ("training_model.h5")

Bây giờ, chúng ta có thể tải mô hình và thực hiện các dự đoán.

# Tải và thực hiện các dự đoán đã lưu_mẫu = mô hình.load_model ('được đào tạo_mẫu.h5') kết quả = đã lưu_mô hình.p dự đoán (thử nghiệm_mục) ########################## ################################# # Chúng ta có thể giải mã bằng cách sử dụng đối tượng scikit-learning để nhận được kết quả được giải mã_result = label_scaler.inverse_transform (results.reshape (-1,1)) in (decoded_result)

Ôi tuyệt !! Bây giờ chúng ta có thể thấy các dự đoán tức là dữ liệu đã giải mã được cung cấp các tính năng đầu vào vào mô hình của chúng ta.

Kết luận

Trong blog về hồi quy với mạng nơ-ron, chúng tôi đã đào tạo mô hình hồi quy đường cơ sở sử dụng mạng nơ-ron sâu trên một tập dữ liệu nhỏ và đơn giản và dự đoán đầu ra cần thiết. Là một thách thức đối với việc học, bạn nên đào tạo nhiều mô hình hơn trên các bộ dữ liệu lớn hơn bằng cách thay đổi kiến ​​trúc và thử các siêu tham số khác nhau như bộ tối ưu hóa và hàm mất mát. Hy vọng bạn thích bài viết của tôi về hồi quy với mạng nơ-ron.

dự án

Hình ảnh 1: https://www.tibco.com/reference-center/what-is-regression-analysis

Lưu ý

Tôi Narasimha Karthik, Học viên học sâu. Tôi là sinh viên năm cuối đại học tại Đại học PES. Hiện đang làm việc với Computer Vision và NLP. Có kinh nghiệm làm việc với các khung công tác Tensorflow và PyTorch. Bạn có thể liên hệ với tôi qua LinkedInTwitter.

Đọc thêm các bài viết trên của chúng tôi Blog của chúng tôi..

Phương tiện hiển thị trong bài viết này không thuộc sở hữu của Analytics Vidhya và được sử dụng theo quyết định riêng của Tác giả. 

tại chỗ_img

Tin tức mới nhất

tại chỗ_img