บทช่วยสอนการถดถอยเชิงเส้นด้วย TensorFlow [ตัวอย่าง]
เอเวลิน คลาร์ก
การถดถอยเชิงเส้นคืออะไร?
การถดถอยเชิงเส้น เป็นแนวทางทางสถิติสำหรับการสร้างแบบจำลองความสัมพันธ์ระหว่างตัวแปรสองตัว การสร้างแบบจำลองนี้เกิดขึ้นระหว่างการตอบสนองแบบสเกลาร์และตัวแปรอธิบายหนึ่งหรือหลายตัว ความสัมพันธ์กับตัวแปรอธิบายหนึ่งตัวแปรเรียกว่าการถดถอยเชิงเส้นอย่างง่าย และสำหรับตัวแปรอธิบายมากกว่าหนึ่งตัวแปร เรียกว่าการถดถอยเชิงเส้นพหุคูณ
TensorFlow มีเครื่องมือสำหรับควบคุมการคำนวณอย่างเต็มรูปแบบ ซึ่งทำได้โดยใช้ API ระดับต่ำ ยิ่งไปกว่านั้น TensorFlow ยังมาพร้อมกับ API มากมายเพื่อดำเนินการหลายอย่าง เรียนรู้เครื่อง อัลกอริทึม นี่คือ API ระดับสูง TensorFlow เรียกสิ่งเหล่านี้ว่าตัวประมาณค่า
- API ระดับต่ำ: สร้างสถาปัตยกรรม ปรับแต่งโมเดลตั้งแต่เริ่มต้น เป็นเรื่องซับซ้อนสำหรับผู้เริ่มต้น
- API ระดับสูง: กำหนดอัลกอริทึม ซึ่งง่ายกว่ามาก TensorFlow มีกล่องเครื่องมือที่เรียกว่า ประมาณการ เพื่อสร้าง ฝึกอบรม ประเมินผล และคาดการณ์
ในบทช่วยสอนนี้ คุณจะใช้ ตัวประมาณค่าเท่านั้น- การคำนวณเร็วขึ้นและง่ายต่อการใช้งาน ส่วนแรกของบทช่วยสอนจะอธิบายวิธีใช้เครื่องมือเพิ่มประสิทธิภาพการไล่ระดับสีเพื่อฝึกการถดถอยเชิงเส้นใน TensorFlow ในส่วนที่สอง คุณจะใช้ชุดข้อมูลบอสตันเพื่อทำนายราคาบ้านโดยใช้ตัวประมาณค่า TensorFlow
วิธีฝึกโมเดลการถดถอยเชิงเส้น
ก่อนที่เราจะเริ่มฝึกโมเดล เรามาดูกันว่าการถดถอยเชิงเส้นคืออะไร
ลองนึกภาพว่าคุณมีตัวแปรสองตัวคือ x และ y และงานของคุณคือทำนายค่าของการรู้ค่าของ หากคุณพล็อตข้อมูล คุณจะเห็นความสัมพันธ์เชิงบวกระหว่างตัวแปรอิสระ x และตัวแปรตาม y
คุณอาจสังเกตว่าถ้า x=1,y จะเท่ากับ 6 โดยประมาณ และถ้า x=2,y จะอยู่ที่ประมาณ 8.5
นี่ไม่ใช่วิธีการที่แม่นยำนักและมีแนวโน้มที่จะเกิดข้อผิดพลาด โดยเฉพาะอย่างยิ่งกับชุดข้อมูลที่มีจุดหลายแสนจุด
การถดถอยเชิงเส้นถูกประเมินด้วยสมการ ตัวแปร y ถูกอธิบายโดยตัวแปรร่วมหนึ่งตัวหรือหลายตัว ในตัวอย่างของคุณ มีตัวแปรตามเพียงตัวเดียวเท่านั้น หากคุณต้องเขียนสมการนี้ มันจะเป็น:
ด้วย:
คืออคติ เช่น ถ้า x=0, y=
คือน้ำหนักที่เกี่ยวข้องกับ x
คือสิ่งตกค้างหรือความผิดพลาดของโมเดล รวมถึงสิ่งที่โมเดลไม่สามารถเรียนรู้จากข้อมูลได้
ลองนึกภาพว่าคุณเหมาะสมกับโมเดลดังกล่าวและคุณพบวิธีแก้ปัญหาดังต่อไปนี้:
- = 3.8
- = 2.78
คุณสามารถแทนตัวเลขเหล่านั้นในสมการได้และจะกลายเป็น:
y= 3.8 + 2.78x
ตอนนี้คุณมีวิธีที่ดีกว่าในการค้นหาค่าของ y แล้ว นั่นคือคุณสามารถแทนที่ x ด้วยค่าใดก็ได้ที่คุณต้องการทำนาย y ในภาพด้านล่าง เราได้แทนที่ x ในสมการด้วยค่าทั้งหมดในชุดข้อมูลและพล็อตผลลัพธ์
เส้นสีแดงแสดงถึงค่าที่พอดี นั่นคือค่า y สำหรับแต่ละค่าของ x คุณไม่จำเป็นต้องเห็นค่าของ x เพื่อทำนาย y เพราะ x แต่ละตัวจะมีค่าใดค่าหนึ่งอยู่ในเส้นสีแดง คุณสามารถทำนายค่า x ที่สูงกว่า 2 ได้ด้วย!
หากคุณต้องการขยายการถดถอยเชิงเส้นไปยังค่าตัวแปรร่วมมากขึ้น คุณสามารถทำได้โดยการเพิ่มตัวแปรให้กับโมเดล ความแตกต่างระหว่างการวิเคราะห์แบบดั้งเดิมกับการถดถอยเชิงเส้นคือการถดถอยเชิงเส้นเพื่อดูว่า y จะตอบสนองอย่างไรสำหรับตัวแปร x แต่ละตัวที่แยกจากกัน
มาดูตัวอย่างกัน ลองนึกภาพว่าคุณต้องการทำนายยอดขายของร้านไอศกรีม ชุดข้อมูลประกอบด้วยข้อมูลต่างๆ เช่น สภาพอากาศ (เช่น ฝนตก แดดออก มีเมฆมาก) ข้อมูลลูกค้า (เช่น เงินเดือน เพศ สถานภาพสมรส)
การวิเคราะห์แบบดั้งเดิมจะพยายามคาดการณ์ยอดขายโดยสมมติว่าคำนวณค่าเฉลี่ยของตัวแปรแต่ละตัว และพยายามประมาณยอดขายในสถานการณ์ที่แตกต่างกัน มันจะนำไปสู่การคาดการณ์ที่ไม่ดีและจำกัดการวิเคราะห์ไว้เฉพาะสถานการณ์ที่เลือก
หากคุณใช้การถดถอยเชิงเส้น คุณสามารถเขียนสมการนี้ได้:
อัลกอริธึมจะค้นหาทางออกที่ดีที่สุดสำหรับตุ้มน้ำหนัก หมายความว่าจะพยายามลดต้นทุนให้เหลือน้อยที่สุด (ความแตกต่างระหว่างเส้นที่ติดตั้งและจุดข้อมูล)
อัลกอริทึมทำงานอย่างไร
อัลกอริธึมจะเลือกหมายเลขสุ่มให้กับแต่ละหมายเลข 
และ 
และแทนที่ค่า x เพื่อให้ได้ค่าทำนายของ y หากชุดข้อมูลมีการสังเกต 100 ครั้ง อัลกอริธึมจะคำนวณค่าที่คาดการณ์ไว้ 100 ค่า
เราสามารถคำนวณข้อผิดพลาดได้ 
ของแบบจำลองซึ่งเป็นผลต่างระหว่างค่าที่ทำนายไว้กับมูลค่าจริง ข้อผิดพลาดเชิงบวกหมายความว่าแบบจำลองประเมินค่าการทำนายของ y ต่ำเกินไป และข้อผิดพลาดเชิงลบหมายความว่าแบบจำลองประเมินค่าการทำนายของ y สูงเกินไป
เป้าหมายของคุณคือลดกำลังสองของข้อผิดพลาดให้เหลือน้อยที่สุด อัลกอริธึมจะคำนวณค่าเฉลี่ยของค่าคลาดเคลื่อนกำลังสอง ขั้นตอนนี้เรียกว่าการลดข้อผิดพลาดให้เหลือน้อยที่สุด สำหรับการถดถอยเชิงเส้นคือ หมายถึงข้อผิดพลาดสแควร์หรือเรียกอีกอย่างว่า MSE ในทางคณิตศาสตร์มันคือ:
ที่ไหน:
น้ำหนักเป็นอย่างนั้น 
หมายถึงค่าที่คาดการณ์ไว้- y คือค่าที่แท้จริง
- m คือจำนวนการสังเกต
หมายถึงค่าที่คาดการณ์ไว้โปรดทราบว่า 
หมายความว่ามันใช้ทรานสโพสของเมทริกซ์ ที่ 
คือสัญกรณ์ทางคณิตศาสตร์ของค่าเฉลี่ย
เป้าหมายคือการหาสิ่งที่ดีที่สุด 
ที่ลด MSE ให้เหลือน้อยที่สุด
หากข้อผิดพลาดโดยเฉลี่ยมีมาก แสดงว่าโมเดลทำงานได้ไม่ดีและไม่ได้เลือกน้ำหนักอย่างเหมาะสม หากต้องการแก้ไขน้ำหนัก คุณต้องใช้เครื่องมือเพิ่มประสิทธิภาพ เครื่องมือเพิ่มประสิทธิภาพแบบดั้งเดิมเรียกว่า โคตรไล่ระดับ.
การไล่ระดับสีแบบไล่ระดับจะใช้อนุพันธ์และลดหรือเพิ่มน้ำหนัก หากอนุพันธ์เป็นบวก น้ำหนักจะลดลง ถ้าอนุพันธ์เป็นลบ น้ำหนักจะเพิ่มขึ้น แบบจำลองจะอัปเดตน้ำหนักและคำนวณข้อผิดพลาดใหม่ กระบวนการนี้ทำซ้ำจนกว่าข้อผิดพลาดจะไม่เปลี่ยนแปลงอีกต่อไป แต่ละกระบวนการเรียกว่า การย้ำ- นอกจากนี้ การไล่ระดับสียังคูณด้วยอัตราการเรียนรู้อีกด้วย มันบ่งบอกถึงความเร็วของการเรียนรู้
หากอัตราการเรียนรู้น้อยเกินไป อัลกอริธึมจะใช้เวลานานมากในการมาบรรจบกัน (เช่น ต้องทำซ้ำหลายครั้ง) หากอัตราการเรียนรู้สูงเกินไป อัลกอริธึมอาจไม่มีวันมาบรรจบกัน
จากภาพด้านบน คุณจะเห็นแบบจำลองทำซ้ำขั้นตอนประมาณ 20 ครั้งก่อนที่จะหาค่าน้ำหนักที่คงที่ จึงเกิดข้อผิดพลาดน้อยที่สุด
โปรดทราบว่าข้อผิดพลาดไม่เท่ากับศูนย์แต่คงที่ประมาณ 5 หมายความว่าโมเดลทำให้เกิดข้อผิดพลาดทั่วไปที่ 5 หากคุณต้องการลดข้อผิดพลาด คุณต้องเพิ่มข้อมูลเพิ่มเติมให้กับโมเดล เช่น ตัวแปรเพิ่มเติม หรือใช้ตัวประมาณค่าที่แตกต่างกัน .
คุณจำสมการแรกได้
น้ำหนักสุดท้ายคือ 3.8 และ 2.78 วิดีโอด้านล่างแสดงให้คุณเห็นว่าการไล่ระดับลงจะปรับฟังก์ชันการสูญเสียให้เหมาะสมเพื่อค้นหาน้ำหนักนี้ได้อย่างไร
วิธีฝึกการถดถอยเชิงเส้นด้วย TensorFlow
เมื่อคุณมีความเข้าใจที่ดีขึ้นเกี่ยวกับสิ่งที่เกิดขึ้นเบื้องหลังแล้ว คุณก็พร้อมที่จะใช้ API ตัวประมาณค่าที่ TensorFlow มอบให้เพื่อฝึกการถดถอยเชิงเส้นครั้งแรกของคุณโดยใช้ TensorFlow
คุณจะใช้ Boston Dataset ซึ่งประกอบด้วยตัวแปรต่อไปนี้
| คริม | อัตราอาชญากรรมต่อหัวแยกตามเมือง |
|---|---|
| zn | สัดส่วนที่ดินที่อยู่อาศัยแบ่งเขตพื้นที่เกิน 25,000 ตร.ฟุต |
| สินธุ | สัดส่วนของพื้นที่ธุรกิจที่ไม่ใช่ร้านค้าปลีกต่อเมือง |
| NOx | ความเข้มข้นของไนตริกออกไซด์ |
| rm | จำนวนห้องเฉลี่ยต่อที่อยู่อาศัย |
| อายุ | สัดส่วนของยูนิตที่มีเจ้าของสร้างขึ้นก่อนปี พ.ศ. 1940 |
| นี้ | ระยะทางถ่วงน้ำหนักไปยังศูนย์จัดหางานบอสตันห้าแห่ง |
| ภาษี | อัตราภาษีทรัพย์สินมูลค่าเต็มต่อ 10,000 ดอลลาร์ |
| พทราติโอ | อัตราส่วนนักเรียนต่อครูแยกตามเมือง |
| เมดวี | ค่ามัธยฐานของบ้านที่มีเจ้าของเป็นพันดอลลาร์ |
คุณจะสร้างชุดข้อมูลที่แตกต่างกันสามชุด:
| ชุด | วัตถุประสงค์ | รูปร่าง |
|---|---|---|
| การฝึกอบรม | ฝึกโมเดลและรับตุ้มน้ำหนัก | 400, 10 |
| การประเมินผล | ประเมินประสิทธิภาพของโมเดลจากข้อมูลที่มองไม่เห็น | 100, 10 |
| ทำนาย | ใช้แบบจำลองเพื่อทำนายมูลค่าบ้านจากข้อมูลใหม่ | 6, 10 |
วัตถุประสงค์คือการใช้คุณลักษณะของชุดข้อมูลเพื่อทำนายมูลค่าบ้าน
ในช่วงส่วนที่สองของบทช่วยสอน คุณจะได้เรียนรู้วิธีใช้ TensorFlow พร้อมวิธีนำเข้าข้อมูลที่แตกต่างกัน 3 วิธี:
- กับแพนด้า
- ด้วยระบบเส้นทาง นัมปี้
- ทีเอฟเท่านั้น
โปรดทราบว่าตัวเลือกทั้งหมด ให้ผลลัพธ์ที่เหมือนกัน
คุณจะได้เรียนรู้วิธีใช้ API ระดับสูงเพื่อสร้าง ฝึกอบรมการประเมินโมเดลการถดถอยเชิงเส้นของ TensorFlow หากคุณใช้ API ระดับต่ำ คุณต้องกำหนดด้วยตนเอง:
- ฟังก์ชั่นการสูญเสีย
- ปรับให้เหมาะสม: การไล่ระดับลง
- การคูณเมทริกซ์
- กราฟและเทนเซอร์
สิ่งนี้น่าเบื่อและซับซ้อนกว่าสำหรับผู้เริ่มต้น
นุ่น
คุณต้องนำเข้าไลบรารีที่จำเป็นเพื่อฝึกโมเดล
import pandas as pd from sklearn import datasets import tensorflow as tf import itertools
ขั้นตอน 1) นำเข้าข้อมูลด้วย หมีแพนด้า.
คุณกำหนดชื่อคอลัมน์และเก็บไว้ใน COLUMNS คุณสามารถใช้ pd.read_csv() เพื่อนำเข้าข้อมูล
COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age",
"dis", "tax", "ptratio", "medv"]
training_set = pd.read_csv (“E:/boston_train.csv”, skiginitialspace=True,skiprows=1, ชื่อ=COLUMNS)
test_set = pd.read_csv (“E:/boston_test.csv”, skiginitialspace=True,skiprows=1, ชื่อ=COLUMNS)
การคาดการณ์_set = pd.read_csv(“E:/boston_predict.csv”, skiginitialspace=True,skiprows=1, ชื่อ=COLUMNS)
คุณสามารถพิมพ์รูปร่างของข้อมูลได้
print(training_set.shape, test_set.shape, prediction_set.shape)
เอาท์พุต
(400, 10) (100, 10) (6, 10)
โปรดทราบว่าป้ายกำกับ (เช่น y ของคุณ) จะรวมอยู่ในชุดข้อมูล ดังนั้นคุณต้องกำหนดอีกสองรายการ อันหนึ่งมีเพียงคุณสมบัติและอันหนึ่งที่มีชื่อของป้ายกำกับเท่านั้น ทั้งสองรายการนี้จะบอกตัวประมาณค่าของคุณว่าคุณลักษณะใดในชุดข้อมูลคืออะไร และชื่อคอลัมน์ใดคือป้ายกำกับ
เสร็จสิ้นด้วยรหัสด้านล่าง
FEATURES = ["crim", "zn", "indus", "nox", "rm",
"age", "dis", "tax", "ptratio"]
LABEL = "medv"
ขั้นตอน 2) แปลงข้อมูล
คุณต้องแปลงตัวแปรตัวเลขให้อยู่ในรูปแบบที่เหมาะสม Tensorflow มีวิธีการแปลงตัวแปรต่อเนื่อง: tf.feature_column.numeric_column()
ในขั้นตอนก่อนหน้านี้ คุณกำหนดรายการคุณลักษณะที่คุณต้องการรวมไว้ในโมเดล ตอนนี้คุณสามารถใช้รายการนี้เพื่อแปลงเป็นข้อมูลตัวเลขได้ หากคุณต้องการแยกคุณลักษณะต่างๆ ในโมเดลของคุณ โปรดทิ้งตัวแปรอย่างน้อยหนึ่งตัวลงในรายการ FEATURES ก่อนที่คุณจะสร้าง Feature_cols
โปรดทราบว่าคุณจะใช้ Python รายการความเข้าใจด้วยรายการคุณสมบัติเพื่อสร้างรายการใหม่ชื่อ Feature_cols ช่วยให้คุณหลีกเลี่ยงการเขียนเก้าครั้ง tf.feature_column.numeric_column() ความเข้าใจในรายการเป็นวิธีที่รวดเร็วและสะอาดยิ่งขึ้นในการสร้างรายการใหม่
feature_cols = [tf.feature_column.numeric_column(k) for k in FEATURES]
ขั้นตอน 3) กำหนดตัวประมาณค่า
ในขั้นตอนนี้ คุณต้องกำหนดการประมาณค่า ปัจจุบัน Tensorflow มีตัวประมาณค่าที่สร้างไว้ล่วงหน้า 6 ตัว ซึ่งรวมถึง 3 ตัวสำหรับงานจำแนกประเภท และ 3 ตัวสำหรับงานการถดถอยของ TensorFlow:
- ผู้ถดถอย
- DNNRegressor
- LinearRegressor
- DNNLineaCombinedRegressor
- แยกประเภท
- DNNลักษณนาม
- ลักษณนามเชิงเส้น
- DNNLineaCombinedClassifier
ในบทช่วยสอนนี้ คุณจะใช้ Linear Regressor หากต้องการเข้าถึงฟังก์ชันนี้ คุณต้องใช้ tf.estimator
ฟังก์ชันต้องการอาร์กิวเมนต์สองตัว:
- Feature_columns: ประกอบด้วยตัวแปรที่จะรวมไว้ในโมเดล
- model_dir: เส้นทางสำหรับจัดเก็บกราฟ บันทึกพารามิเตอร์โมเดล ฯลฯ
Tensorflow จะสร้างไฟล์ชื่อ train ในไดเร็กทอรีการทำงานของคุณโดยอัตโนมัติ คุณต้องใช้เส้นทางนี้เพื่อเข้าถึง Tensorboard ดังที่แสดงในตัวอย่างการถดถอยของ TensorFlow ด้านล่าง
estimator = tf.estimator.LinearRegressor(
feature_columns=feature_cols,
model_dir="train")
เอาท์พุต
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}
ส่วนที่ยุ่งยากของ TensorFlow คือวิธีการป้อนโมเดล Tensorflow ได้รับการออกแบบมาเพื่อทำงานกับการประมวลผลแบบขนานและชุดข้อมูลขนาดใหญ่มาก เนื่องจากข้อจำกัดของทรัพยากรเครื่องจักร จึงไม่สามารถป้อนข้อมูลทั้งหมดในครั้งเดียวให้กับโมเดลได้ เพื่อทำเช่นนั้น คุณจะต้องป้อนข้อมูลเป็นชุดในแต่ละครั้ง โปรดทราบว่าเรากำลังพูดถึงชุดข้อมูลขนาดใหญ่ที่มีบันทึกนับล้านรายการขึ้นไป หากคุณไม่เพิ่มแบทช์ คุณจะพบกับข้อผิดพลาดของหน่วยความจำ
ตัวอย่างเช่น หากข้อมูลของคุณมีการสังเกต 100 ครั้ง และคุณกำหนดขนาดแบทช์เป็น 10 หมายความว่าโมเดลจะเห็นการสังเกต 10 ครั้งในแต่ละรอบซ้ำ (10*10)
เมื่อโมเดลเห็นข้อมูลทั้งหมดแล้ว ก็จะเสร็จสิ้นหนึ่งรายการ ยุค- ยุคจะกำหนดจำนวนครั้งที่คุณต้องการให้โมเดลดูข้อมูล เป็นการดีกว่าถ้าตั้งค่าขั้นตอนนี้เป็นไม่มีเลย และปล่อยให้โมเดลดำเนินการตามจำนวนครั้งของการวนซ้ำ
ข้อมูลที่สองที่ต้องเพิ่มคือหากคุณต้องการสับเปลี่ยนข้อมูลก่อนการวนซ้ำแต่ละครั้ง ในระหว่างการฝึก สิ่งสำคัญคือต้องสับเปลี่ยนข้อมูลเพื่อให้โมเดลไม่เรียนรู้รูปแบบเฉพาะของชุดข้อมูล หากโมเดลเรียนรู้รายละเอียดของรูปแบบพื้นฐานของข้อมูล โมเดลจะพบปัญหาในการสรุปการคาดการณ์สำหรับข้อมูลที่ไม่เคยเห็นมาก่อน ซึ่งเรียกว่า ฟิตเกินไป- แบบจำลองนี้ทำงานได้ดีกับข้อมูลการฝึก แต่ไม่สามารถคาดการณ์ได้อย่างถูกต้องสำหรับข้อมูลที่มองไม่เห็น
TensorFlow ทำให้สองขั้นตอนนี้ทำได้ง่าย เมื่อข้อมูลไปที่ไปป์ไลน์ ระบบจะรู้ว่าต้องมีการสังเกตจำนวนเท่าใด (เป็นชุด) และต้องสับเปลี่ยนข้อมูลหรือไม่
หากต้องการสั่ง Tensorflow ว่าจะป้อนโมเดลอย่างไร คุณสามารถใช้ pandas_input_fn วัตถุนี้ต้องการพารามิเตอร์ 5 ตัว:
- x: ข้อมูลคุณลักษณะ
- y: ข้อมูลป้ายกำกับ
- ชุด_ขนาด: ชุด โดยค่าเริ่มต้น 128
- num_epoch: จำนวนยุค โดยค่าเริ่มต้นคือ 1
- สับเปลี่ยน: สับเปลี่ยนหรือไม่ข้อมูล ตามค่าเริ่มต้น ไม่มี
คุณต้องป้อนโมเดลหลายครั้งเพื่อกำหนดฟังก์ชันเพื่อทำซ้ำขั้นตอนนี้ ฟังก์ชั่นทั้งหมดนี้ 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)
วิธีปกติในการประเมินประสิทธิภาพของแบบจำลองคือ:
- ฝึกโมเดล
- ประเมินโมเดลในชุดข้อมูลอื่น
- ทำนายกัน
เครื่องมือประมาณค่า Tensorflow มีฟังก์ชันที่แตกต่างกัน 3 แบบเพื่อให้ดำเนินการ 3 ขั้นตอนนี้ได้อย่างง่ายดาย
ขั้นตอน 4): ฝึกโมเดล
คุณสามารถใช้รถไฟตัวประมาณค่าเพื่อประเมินแบบจำลองได้ ตัวประมาณค่ารถไฟจำเป็นต้องมี input_fn และขั้นตอนจำนวนหนึ่ง คุณสามารถใช้ฟังก์ชันที่คุณสร้างไว้ด้านบนเพื่อป้อนโมเดลได้ จากนั้น คุณสั่งให้โมเดลทำซ้ำ 1000 ครั้ง โปรดทราบว่าคุณไม่ได้ระบุจำนวนยุค แต่ปล่อยให้โมเดลวนซ้ำ 1000 ครั้ง หากคุณตั้งค่าจำนวนยุคเป็น 1 โมเดลจะวนซ้ำ 4 ครั้ง: มี 400 บันทึกในชุดการฝึก และขนาดแบทช์คือ 128
- 128 แถว
- 128 แถว
- 128 แถว
- 16 แถว
ดังนั้นจึงง่ายกว่าที่จะตั้งค่าจำนวนยุคเป็นไม่มีและกำหนดจำนวนการวนซ้ำดังแสดงในตัวอย่างการจัดหมวดหมู่ TensorFlow ด้านล่าง
estimator.train(input_fn=get_input_fn(training_set,
num_epochs=None,
n_batch = 128,
shuffle=False),
steps=1000)
เอาท์พุต
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.
คุณสามารถตรวจสอบ Tensorboard ได้ด้วยคำสั่งต่อไปนี้:
activate hello-tf # For MacOS tensorboard --logdir=./train # For Windows tensorboard --logdir=train
ขั้นตอน 5) ประเมินแบบจำลองของคุณ
คุณสามารถประเมินความพอดีของแบบจำลองของคุณในชุดทดสอบด้วยโค้ดด้านล่าง:
ev = estimator.evaluate(
input_fn=get_input_fn(test_set,
num_epochs=1,
n_batch = 128,
shuffle=False))
เอาท์พุต
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
คุณสามารถพิมพ์การสูญเสียด้วยรหัสด้านล่าง:
loss_score = ev["loss"]
print("Loss: {0:f}".format(loss_score))
เอาท์พุต
Loss: 3215.895996
แบบจำลองมีการสูญเสีย 3215 คุณสามารถตรวจสอบสถิติสรุปเพื่อให้ทราบว่าข้อผิดพลาดมีขนาดใหญ่เพียงใด
training_set['medv'].describe()
เอาท์พุต
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
จากสถิติสรุปข้างต้น ทราบไหมว่า ราคาเฉลี่ยบ้านอยู่ที่ 22 โดยมีราคาขั้นต่ำ 9 และสูงสุด 50 แบบจำลองทำให้เกิดข้อผิดพลาดทั่วไปมูลค่า 3 ดอลลาร์
ขั้นตอน 6) ทำการทำนาย
สุดท้าย คุณสามารถใช้ตัวประมาณค่า TensorFlow ทำนายมูลค่าบ้านในบอสตัน 6 หลังได้
y = estimator.predict(
input_fn=get_input_fn(prediction_set,
num_epochs=1,
n_batch = 128,
shuffle=False))
หากต้องการพิมพ์ค่าประมาณของ คุณสามารถใช้รหัสนี้:
predictions = list(p["predictions"] for p in itertools.islice(y, 6))print("Predictions: {}".format(str(predictions)))
เอาท์พุต
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)]
แบบจำลองนี้คาดการณ์ค่าต่อไปนี้:
| บ้าน | คำทำนาย | |
|---|---|---|
| 1 | 32.29 | |
| 2 | 18.96 | |
| 3 | 27.27 | |
| 4 | 29.29 | |
| 5 | 16.43 | |
| 7 | 21.46 |
โปรดทราบว่าเราไม่ทราบมูลค่าที่แท้จริงของ ในบทช่วยสอนการเรียนรู้เชิงลึก คุณจะพยายามเอาชนะโมเดลเชิงเส้น
นัมปี โซลูชั่น
ส่วนนี้อธิบายวิธีฝึกโมเดลโดยใช้ตัวประมาณค่าตัวเลขเพื่อป้อนข้อมูล วิธีการนี้เหมือนกับที่คุณจะใช้ตัวประมาณค่า numpy_input_fn
training_set_n = pd.read_csv(“E:/boston_train.csv”).ค่า
test_set_n = pd.read_csv(“E:/boston_test.csv”).ค่า
การคาดการณ์_set_n = pd.read_csv(“E:/boston_predict.csv”).ค่า
ขั้นตอน 1) นำเข้าข้อมูล
ก่อนอื่น คุณต้องแยกความแตกต่างของตัวแปรคุณลักษณะจากป้ายกำกับ คุณต้องทำเช่นนี้สำหรับข้อมูลการฝึกอบรมและการประเมินผล กำหนดฟังก์ชันเพื่อแยกข้อมูลได้เร็วกว่า
def prepare_data(df):
X_train = df[:, :-3]
y_train = df[:,-3]
return X_train, y_train
คุณสามารถใช้ฟังก์ชันนี้เพื่อแยกป้ายกำกับออกจากคุณลักษณะของชุดข้อมูลฝึก/ประเมินผลได้
X_train, y_train = prepare_data(training_set_n) X_test, y_test = prepare_data(test_set_n)
คุณต้องแยกคอลัมน์สุดท้ายของชุดข้อมูลการคาดการณ์ออกเนื่องจากมีเฉพาะ NaN
x_predict = prediction_set_n[:, :-2]
ยืนยันรูปร่างของอาร์เรย์ โปรดทราบว่าฉลากไม่ควรมีขนาด ซึ่งหมายถึง (400,)
print(X_train.shape, y_train.shape, x_predict.shape)
เอาท์พุต
(400, 9) (400,) (6, 9)
คุณสามารถสร้างคอลัมน์คุณลักษณะได้ดังต่อไปนี้:
feature_columns = [ tf.feature_column.numeric_column('x', shape=X_train.shape[1:])]
ตัวประมาณค่าถูกกำหนดไว้เหมือนเมื่อก่อน คุณกำหนดคอลัมน์คุณลักษณะและตำแหน่งที่จะบันทึกกราฟ
estimator = tf.estimator.LinearRegressor(
feature_columns=feature_columns,
model_dir="train1")
เอาท์พุต
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}
คุณสามารถใช้การประมาณค่าตัวเลขเพื่อป้อนข้อมูลให้กับโมเดล จากนั้นฝึกโมเดล โปรดทราบว่าเรากำหนดฟังก์ชัน input_fn ก่อนเพื่อให้อ่านง่าย
# Train the estimatortrain_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)
เอาท์พุต
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>
คุณทำซ้ำขั้นตอนเดียวกันโดยใช้ตัวประมาณค่าอื่นเพื่อประเมินแบบจำลองของคุณ
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)
เอาท์พุต
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}
ในที่สุดคุณสามารถคำนวณคำทำนายได้ มันควรจะเหมือนกับหมีแพนด้า
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)))
เอาท์พุต
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)]
โซลูชันเทนเซอร์โฟลว์
ส่วนสุดท้ายเป็นเรื่องเกี่ยวกับโซลูชัน TensorFlow โดยเฉพาะ วิธีนี้ซับซ้อนกว่าวิธีอื่นเล็กน้อย
โปรดทราบว่าถ้าคุณใช้ Jupyter สมุดบันทึกคุณต้องรีสตาร์ทและทำความสะอาดเคอร์เนลเพื่อรันเซสชันนี้
TensorFlow ได้สร้างเครื่องมือที่ยอดเยี่ยมในการส่งข้อมูลไปยังไปป์ไลน์ ในส่วนนี้ คุณจะสร้างฟังก์ชัน input_fn ด้วยตัวเอง
ขั้นตอน 1) กำหนดเส้นทางและรูปแบบของข้อมูล
ก่อนอื่น คุณประกาศตัวแปรสองตัวด้วยเส้นทางของไฟล์ csv โปรดทราบว่าคุณมีไฟล์สองไฟล์ ไฟล์หนึ่งสำหรับชุดการฝึกและอีกไฟล์สำหรับชุดการทดสอบ
import tensorflow as tf
df_train = "E:/boston_train.csv"
df_eval = "E:/boston_test.csv"
จากนั้น คุณจะต้องกำหนดคอลัมน์ที่คุณต้องการใช้จากไฟล์ csv เราจะใช้ทั้งหมด หลังจากนั้นคุณจะต้องประกาศประเภทของตัวแปรนั้น
ตัวแปรลอยตัวถูกกำหนดโดย [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]]
ขั้นตอน 2) กำหนดฟังก์ชัน input_fn
ฟังก์ชั่นสามารถแบ่งออกเป็นสามส่วน:
- นำเข้าข้อมูล
- สร้างตัววนซ้ำ
- ใช้ข้อมูล
ด้านล่างนี้เป็นโค้ดโดยรวมเพื่อกำหนดฟังก์ชัน รหัสจะอธิบายภายหลัง
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
** นำเข้าข้อมูล **
สำหรับไฟล์ CSV วิธีชุดข้อมูลจะอ่านทีละบรรทัด หากต้องการสร้างชุดข้อมูล คุณต้องใช้ออบเจ็กต์ TextLineชุดข้อมูล ชุดข้อมูลของคุณมีส่วนหัว ดังนั้นคุณต้องใช้ข้าม (1) เพื่อข้ามบรรทัดแรก ณ จุดนี้ คุณจะอ่านเฉพาะข้อมูลและไม่รวมส่วนหัวในไปป์ไลน์ หากต้องการป้อนโมเดล คุณต้องแยกคุณลักษณะออกจากป้ายกำกับ วิธีการที่ใช้ในการแปลงข้อมูลคือการแม็ป
เมธอดนี้เรียกใช้ฟังก์ชันที่คุณจะสร้างขึ้นเพื่อแนะนำวิธีการแปลงข้อมูล โดยสรุป คุณต้องส่งข้อมูลใน TextLineวัตถุชุดข้อมูล ยกเว้นส่วนหัวและใช้การแปลงที่ได้รับคำสั่งจากคำอธิบายฟังก์ชัน คำอธิบายโค้ด
- tf.dataTextLineชุดข้อมูล (data_file): บรรทัดนี้อ่านไฟล์ csv
- .skip(1) : ข้ามส่วนหัว
- .map(parse_csv)): แยกวิเคราะห์บันทึกลงในเทนเซอร์ คุณต้องกำหนดฟังก์ชันเพื่อสั่งการวัตถุแผนที่ คุณสามารถเรียกใช้ฟังก์ชันนี้ parse_csv
ฟังก์ชันนี้จะวิเคราะห์ไฟล์ csv โดยใช้เมธอด tf.decode_csv และประกาศคุณลักษณะและป้ายกำกับ คุณลักษณะเหล่านี้สามารถประกาศเป็นพจนานุกรมหรือทูเพิลได้ คุณใช้เมธอดพจนานุกรมเพราะสะดวกกว่า คำอธิบายโค้ด
- tf.decode_csv(value, record_defaults= RECORDS_ALL): เมธอด decode_csv ใช้เอาต์พุตของ TextLineชุดข้อมูลสำหรับอ่านไฟล์ CSV record_defaults จะสั่ง TensorFlow เกี่ยวกับประเภทคอลัมน์
- dict(zip(_CSV_COLUMNS, columns)): เติมพจนานุกรมด้วยคอลัมน์ทั้งหมดที่แยกออกมาในระหว่างการประมวลผลข้อมูลนี้
- features.pop('median_house_value'): แยกตัวแปรเป้าหมายออกจากตัวแปรคุณลักษณะและสร้างตัวแปรป้ายกำกับ
ชุดข้อมูลต้องการองค์ประกอบเพิ่มเติมเพื่อป้อนเทนเซอร์ซ้ำๆ ที่จริงแล้ว คุณต้องเพิ่มวิธีการทำซ้ำเพื่อให้ชุดข้อมูลสามารถฟีดโมเดลต่อไปได้อย่างไม่มีกำหนด หากคุณไม่เพิ่มวิธีการ โมเดลจะวนซ้ำเพียงครั้งเดียว จากนั้นจึงเกิดข้อผิดพลาดเนื่องจากไม่มีการป้อนข้อมูลในไปป์ไลน์อีกต่อไป
หลังจากนั้น คุณสามารถควบคุมขนาดแบทช์ด้วยวิธีแบทช์ได้ หมายความว่าคุณบอกชุดข้อมูลว่ามีข้อมูลจำนวนเท่าใดที่คุณต้องการส่งผ่านไปป์ไลน์สำหรับการวนซ้ำแต่ละครั้ง หากคุณกำหนดขนาดชุดใหญ่ โมเดลจะช้า
ขั้นตอนที่ 3) สร้างตัววนซ้ำ
ตอนนี้คุณพร้อมสำหรับขั้นตอนที่สองแล้ว: สร้างตัววนซ้ำเพื่อส่งคืนองค์ประกอบในชุดข้อมูล
วิธีที่ง่ายที่สุดในการสร้างตัวดำเนินการคือใช้วิธีการ make_one_shot_iterator
หลังจากนั้น คุณสามารถสร้างคุณลักษณะและป้ายกำกับจากตัววนซ้ำได้
ขั้นตอนที่ 4) ใช้ข้อมูล
คุณสามารถตรวจสอบสิ่งที่เกิดขึ้นได้ด้วยฟังก์ชัน input_fn คุณต้องเรียกใช้ฟังก์ชันในเซสชันเพื่อใช้ข้อมูล คุณลองด้วยขนาดชุดงานเท่ากับ 1
โปรดทราบว่าระบบจะพิมพ์คุณลักษณะต่างๆ ในพจนานุกรมและป้ายชื่อเป็นอาร์เรย์
มันจะแสดงบรรทัดแรกของไฟล์ csv คุณสามารถลองเรียกใช้โค้ดนี้หลายครั้งด้วยขนาดแบตช์ที่แตกต่างกัน
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)
เอาท์พุต
({'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))
ขั้นตอน 4) กำหนดคอลัมน์คุณลักษณะ
คุณต้องกำหนดคอลัมน์ตัวเลขดังนี้:
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')
โปรดทราบว่าคุณต้องรวมตัวแปรทั้งหมดไว้ในที่เก็บข้อมูล
base_columns = [X1, X2, X3,X4, X5, X6,X7, X8, X9]
ขั้นตอน 5) สร้างโมเดล
คุณสามารถฝึกโมเดลด้วยตัวประมาณค่า LinearRegressor
model = tf.estimator.LinearRegressor(feature_columns=base_columns, model_dir='train3')
เอาท์พุต
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}
คุณต้องใช้ฟังก์ชัน lambda เพื่ออนุญาตให้เขียนอาร์กิวเมนต์ในฟังก์ชัน inpu_fn ถ้าคุณไม่ได้ใช้ก ฟังก์ชันแลมบ์ดาคุณไม่สามารถฝึกโมเดลได้
# Train the estimatormodel.train(steps =1000,
input_fn= lambda : input_fn(df_train,batch_size=128, num_epoch = None))
เอาท์พุต
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>
คุณสามารถประเมินความพอดีของแบบจำลองของคุณในชุดทดสอบด้วยโค้ดด้านล่าง:
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]))
เอาท์พุต
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
ขั้นตอนสุดท้ายคือการทำนายค่าของตามค่าของ เมทริกซ์ของคุณลักษณะ คุณสามารถเขียนพจนานุกรมด้วยค่าที่คุณต้องการทำนายได้ โมเดลของคุณมีคุณลักษณะ 9 ประการ ดังนั้นคุณต้องระบุค่าสำหรับแต่ละรายการ แบบจำลองจะให้คำทำนายสำหรับแต่ละรายการ
ในโค้ดด้านล่าง คุณได้เขียนค่าของแต่ละฟีเจอร์ที่มีอยู่ในไฟล์ df_predict csv
คุณต้องเขียนฟังก์ชัน input_fn ใหม่เนื่องจากไม่มีป้ายกำกับในชุดข้อมูล คุณสามารถใช้ API from_tensor จากชุดข้อมูล
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_inputpred_results = model.predict(input_fn=test_input_fn)
สุดท้ายคุณพิมพ์คำทำนาย
for pred in enumerate(pred_results): print(pred)
เอาท์พุต
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)})
สรุป
หากต้องการฝึกโมเดล คุณต้อง:
- กำหนดคุณสมบัติ: ตัวแปรอิสระ: X
- กำหนดป้ายกำกับ: ตัวแปรตาม: y
- สร้างชุดรถไฟ/ชุดทดสอบ
- กำหนดน้ำหนักเริ่มต้น
- กำหนดฟังก์ชันการสูญเสีย: MSE
- ปรับโมเดลให้เหมาะสม: การไล่ระดับลง
- กำหนด:
- อัตราการเรียนรู้
- จำนวนยุค
- ขนาดแบทช์
ในบทช่วยสอนนี้ คุณได้เรียนรู้วิธีใช้ API ระดับสูงสำหรับตัวประมาณค่า TensorFlow การถดถอยเชิงเส้น คุณต้องกำหนด:
- คอลัมน์คุณลักษณะ หากต่อเนื่อง: tf.feature_column.numeric_column() คุณสามารถเติมรายการด้วยความเข้าใจรายการหลาม
- ตัวประมาณค่า: tf.estimator.LinearRegressor(feature_columns, model_dir)
- ฟังก์ชันในการนำเข้าข้อมูล ขนาดแบตช์ และยุค: input_fn()
หลังจากนั้นคุณก็พร้อมที่จะฝึกฝน ประเมิน และทำนายด้วย train() ประเมิน() และทำนาย()
