การถดถอยเชิงเส้น TensorFlow พร้อมแง่มุมและเงื่อนไขการโต้ตอบ

การถดถอยเชิงเส้นของ TensorFlow

ในบทช่วยสอนนี้ คุณจะได้เรียนรู้วิธีตรวจสอบข้อมูลและเตรียมข้อมูลเพื่อสร้างงานการถดถอยเชิงเส้นอย่างง่าย

บทช่วยสอนนี้แบ่งออกเป็นสองส่วน:

• มองหาปฏิสัมพันธ์
• ทดสอบโมเดล

ตัว Vortex Indicator ได้ถูกนำเสนอลงในนิตยสาร กวดวิชาก่อนหน้านี้คุณใช้ชุดข้อมูลของบอสตันเพื่อประมาณราคาเฉลี่ยของบ้าน ชุดข้อมูลของบอสตันมีขนาดเล็ก โดยมีการสังเกตเพียง 506 รายการ ชุดข้อมูลนี้ถือเป็นเกณฑ์มาตรฐานในการทดลองใช้อัลกอริทึมการถดถอยเชิงเส้นแบบใหม่

ชุดข้อมูลประกอบด้วย:

ในบทช่วยสอนนี้ เราจะประมาณราคาเฉลี่ยโดยใช้ตัวถดถอยเชิงเส้น แต่จุดสนใจอยู่ที่กระบวนการใดกระบวนการหนึ่งโดยเฉพาะ เรียนรู้เครื่อง: “การเตรียมข้อมูล”

แบบจำลองสรุปรูปแบบในข้อมูล หากต้องการจับภาพรูปแบบดังกล่าว คุณต้องค้นหารูปแบบดังกล่าวก่อน แนวทางปฏิบัติที่ดีคือการวิเคราะห์ข้อมูลก่อนใช้งานอัลกอริทึมการเรียนรู้ของเครื่อง

การเลือกคุณสมบัติที่เหมาะสมจะสร้างความแตกต่างให้กับความสำเร็จของโมเดลของคุณ ลองนึกภาพคุณพยายามประมาณการค่าจ้างของบุคคล หากคุณไม่รวมเพศเป็นตัวแปรร่วม คุณจะจบลงด้วยการประมาณการที่ไม่ดี

อีกวิธีในการปรับปรุงแบบจำลองคือการดูความสัมพันธ์ระหว่างตัวแปรอิสระ กลับมาที่ตัวอย่าง คุณอาจคิดว่าการศึกษาเป็นผู้สมัครที่ยอดเยี่ยมในการทำนายค่าจ้างและอาชีพด้วย พูดได้อย่างยุติธรรมว่าอาชีพนั้นขึ้นอยู่กับระดับการศึกษา กล่าวคือ การศึกษาระดับอุดมศึกษามักจะนำไปสู่อาชีพที่ดีขึ้น หากเราสรุปแนวคิดนี้ เราสามารถพูดได้ว่าความสัมพันธ์ระหว่างตัวแปรตามและตัวแปรอธิบายสามารถขยายไปยังตัวแปรอธิบายอีกตัวแปรหนึ่งได้

เพื่อจับผลกระทบที่จำกัดของการศึกษาต่ออาชีพ เราสามารถใช้คำโต้ตอบได้

หากดูสมการค่าจ้างจะกลายเป็น:

If เป็นบวก แสดงว่าระดับการศึกษาเพิ่มเติมส่งผลให้มูลค่ามัธยฐานของบ้านเพิ่มขึ้นสูงขึ้นสำหรับระดับอาชีพที่สูง กล่าวอีกนัยหนึ่งคือมีผลกระทบปฏิสัมพันธ์ระหว่างการศึกษาและอาชีพ

ตระกูลตัวประมาณค่าเดียวกันนี้ยังใช้ในการขับเคลื่อน ตัวจำแนกเชิงเส้น เมื่อป้ายกำกับเป็นคลาสแทนที่จะเป็นราคา ในบทเรียนนี้ เราจะลองดูว่าตัวแปรใดบ้างที่เป็นตัวเลือกที่ดีสำหรับเทอมปฏิสัมพันธ์ เราจะทดสอบว่าการเพิ่มข้อมูลประเภทนี้จะนำไปสู่การทำนายราคาที่ดีขึ้นหรือไม่

สถิติโดยย่อ

มีขั้นตอนบางอย่างที่คุณสามารถปฏิบัติตามก่อนที่จะเริ่มสร้างแบบจำลอง ดังที่กล่าวไว้ก่อนหน้านี้ แบบจำลองเป็นการสรุปผลจากข้อมูล วิธีปฏิบัติที่ดีที่สุดคือการทำความเข้าใจข้อมูลก่อน แล้วจึงทำการทำนาย หากคุณไม่รู้จักข้อมูลของคุณ โอกาสที่คุณจะปรับปรุงแบบจำลองของคุณได้ก็จะน้อยลง

ในขั้นตอนแรก ให้โหลดข้อมูลเป็น dataframe ของ pandas และสร้างชุดการฝึกและชุดการทดสอบ

คำแนะนำ: สำหรับบทเรียนนี้ คุณต้องติดตั้ง matplotlib และ seaborn ไว้ก่อน Pythonคุณสามารถติดตั้งได้ Python แพ็คเกจได้ทันทีด้วย Jupyter. คุณ ไม่ควร ทำเช่นนี้

!conda install -- yes matplotlib

แต่

import sys
!{sys.executable} -m pip install matplotlib # Already installed
!{sys.executable} -m pip install seaborn 

โปรดทราบว่าขั้นตอนนี้ไม่จำเป็นหากคุณติดตั้ง matplotlib และ seaborn

Matplotlib เป็นไลบรารีสำหรับสร้างกราฟ PythonSeaborn เป็นไลบรารีสำหรับการแสดงภาพข้อมูลทางสถิติที่สร้างขึ้นบนพื้นฐานของ matplotlib โดยมีคุณสมบัติดังนี้tracเนื้อเรื่องน่าสนใจและสวยงาม

รหัสด้านล่างนำเข้าไลบรารีที่จำเป็น

import pandas as pd
from sklearn import datasets
import tensorflow as tf
from sklearn.datasets import load_boston
import numpy as np

sklearn ของห้องสมุดประกอบด้วยชุดข้อมูลของบอสตัน คุณสามารถเรียก API เพื่อนำเข้าข้อมูลได้

หมายเหตุเกี่ยวกับเวอร์ชัน: load_boston ถูกยกเลิกการใช้งานใน scikit-learn เวอร์ชัน 1.0 และ ถูกลบออกใน scikit-learn เวอร์ชัน 1.2 เนื่องจากชุดข้อมูลเข้ารหัสคุณลักษณะที่เกี่ยวข้องกับเชื้อชาติ ในการติดตั้งปัจจุบัน ให้ใช้ ดึงข้อมูล_ที่อยู่อาศัยแคลิฟอร์เนีย หรือโหลดไฟล์ต้นฉบับด้วยตนเองก็ได้ ขั้นตอนการทำงานที่แสดงด้านล่างยังคงเหมือนเดิม ต่างกันเพียงแค่ตัวโหลดเท่านั้น

boston = load_boston()
df = pd.DataFrame(boston.data)

ชื่อของฟีเจอร์จะถูกจัดเก็บไว้ในอ็อบเจ็กต์ feature_names ในรูปแบบอาร์เรย์

boston.feature_names

เอาท์พุต

array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='<U7')

คุณสามารถเปลี่ยนชื่อคอลัมน์ได้

df.columns = boston.feature_names
df['PRICE'] = boston.target
df.head(2)

คุณแปลงตัวแปร CHAS เป็นตัวแปรสตริงและติดป้ายกำกับด้วยใช่ถ้า CHAS = 1 และไม่ใช่ถ้า CHAS = 0

df['CHAS'] = df['CHAS'].map({1:'yes', 0:'no'})
df['CHAS'].head(5)
0    no
1    no
2    no
3    no
4    no
Name: CHAS, dtype: object

สำหรับแพนด้า การแยกชุดข้อมูลเป็นเรื่องง่าย คุณสุ่มแบ่งชุดข้อมูลด้วยชุดการฝึก 80 เปอร์เซ็นต์และชุดการทดสอบ 20 เปอร์เซ็นต์ นุ่น มีฟังก์ชันการสุ่มตัวอย่างในตัวเพื่อแบ่งเฟรมข้อมูล

frac พารามิเตอร์แรกคือค่าตั้งแต่ 0 ถึง 1 คุณตั้งค่าเป็น 0.8 เพื่อเลือกเฟรมข้อมูลแบบสุ่ม 80 เปอร์เซ็นต์

random_state จะแก้ไขการสุ่มลำดับ ทำให้แถวที่แสดงผลเหมือนกันสำหรับทุกคน

### Create train/test set
df_train=df.sample(frac=0.8,random_state=200)
df_test=df.drop(df_train.index)

คุณสามารถรับรูปร่างของข้อมูลได้ มันควรจะเป็น:

• ชุดรถไฟ: 506*0.8 = 405
• ชุดทดสอบ: 506*0.2 = 101

print(df_train.shape, df_test.shape)

เอาท์พุต

(405, 14) (101, 14)

df_test.head(5)

เอาท์พุต

ข้อมูลยุ่งเหยิง มักจะไม่สมดุลและโรยด้วยค่าผิดปกติซึ่งทำให้การวิเคราะห์และการฝึกอบรมการเรียนรู้ของเครื่องไม่มีประสิทธิภาพ

ขั้นตอนแรกในการล้างชุดข้อมูลคือการทำความเข้าใจว่าจำเป็นต้องทำความสะอาดจุดใด การล้างชุดข้อมูลอาจทำได้ยาก โดยเฉพาะอย่างยิ่งในลักษณะทั่วไป

การขอ Google ทีมวิจัยได้พัฒนาเครื่องมือสำหรับงานนี้ขึ้นมา โดยเรียกว่า แง่มุม ซึ่งช่วยให้คุณเห็นภาพข้อมูลและแบ่งข้อมูลออกเป็นส่วนๆ ได้หลากหลายวิธี นี่เป็นจุดเริ่มต้นที่ดีในการทำความเข้าใจโครงสร้างของชุดข้อมูล

ฟีเจอร์ Facets ช่วยให้คุณค้นหาจุดที่ข้อมูลไม่ตรงกับที่คุณคาดหวัง

ยกเว้นแอปพลิเคชันบนเว็บของพวกเขา Google ทำให้การฝังชุดเครื่องมือลงในระบบทำได้ง่ายขึ้น Jupyter สมุดบันทึก.

Facets มีสองส่วน:

• ภาพรวมของแง่มุม
• เจาะลึกแง่มุมต่างๆ

ภาพรวมของแง่มุม

ภาพรวมของ Facets จะให้ภาพรวมของชุดข้อมูล ภาพรวมของ Facets จะแบ่งคอลัมน์ของข้อมูลออกเป็นแถวของข้อมูลที่สำคัญซึ่งแสดง

1. เปอร์เซ็นต์ของการสังเกตที่ขาดหายไป
2. ค่าต่ำสุดและสูงสุด
3. สถิติต่างๆ เช่น ค่าเฉลี่ย ค่ามัธยฐาน และส่วนเบี่ยงเบนมาตรฐาน
4. นอกจากนี้ยังเพิ่มคอลัมน์ที่แสดงเปอร์เซ็นต์ของค่าที่เป็นศูนย์ ซึ่งจะมีประโยชน์เมื่อค่าส่วนใหญ่เป็นศูนย์
5. คุณสามารถดูการแจกแจงเหล่านี้ได้บนชุดข้อมูลทดสอบ รวมถึงชุดฝึกอบรมสำหรับแต่ละฟีเจอร์ ซึ่งหมายความว่าคุณสามารถตรวจสอบซ้ำอีกครั้งว่าการทดสอบมีการแจกแจงที่คล้ายคลึงกันกับข้อมูลฝึกอบรมหรือไม่

นี่เป็นขั้นต่ำที่ต้องทำก่อนงานแมชชีนเลิร์นนิงใดๆ ด้วยเครื่องมือนี้ คุณจะไม่พลาดขั้นตอนสำคัญนี้ และจะเน้นย้ำถึงความผิดปกติบางอย่าง

เจาะลึกแง่มุมต่างๆ

Facets Deep Dive เป็นเครื่องมือที่ยอดเยี่ยม ช่วยให้คุณมองเห็นภาพรวมของชุดข้อมูลได้ชัดเจนยิ่งขึ้น และสามารถซูมเข้าไปดูข้อมูลแต่ละส่วนได้อย่างละเอียด หมายความว่าคุณสามารถจัดกลุ่มข้อมูลตามแถวและคอลัมน์ได้ในทุกคุณลักษณะของชุดข้อมูล

เราจะใช้เครื่องมือทั้งสองนี้กับชุดข้อมูลบอสตัน

หมายเหตุ: คุณไม่สามารถใช้ภาพรวม Facets และการเจาะลึก Facets พร้อมกันได้ คุณต้องล้างสมุดบันทึกก่อนจึงจะเปลี่ยนเครื่องมือได้

ก่อนใช้งานเครื่องมือทั้งสอง ต้องติดตั้ง Facets ลงในสภาพแวดล้อมของโน้ตบุ๊กก่อน

ติดตั้ง Facet

คุณสามารถใช้เว็บแอป Facet เพื่อการวิเคราะห์ส่วนใหญ่ได้ ในบทช่วยสอนนี้ คุณจะเห็นวิธีใช้งานภายในก Jupyter สมุดบันทึก.

ก่อนอื่นคุณต้องติดตั้ง nbextensions ก่อน ซึ่งทำได้ด้วยโค้ดนี้ เพียงคัดลอกและวางโค้ดต่อไปนี้ลงในเทอร์มินัลของเครื่องของคุณ

pip install jupyter_contrib_nbextensions

หลังจากนั้นคุณจะต้องโคลนที่เก็บข้อมูลในคอมพิวเตอร์ของคุณ คุณมีสองทางเลือก:

ตัวเลือกที่ 1) คัดลอกและวางรหัสนี้ในเทอร์มินัล (แนะนำ)

หากคุณยังไม่ได้ติดตั้ง Git บนเครื่องของคุณ โปรดไปที่นี่ URL กิตสำหรับ Windows ดาวน์โหลดหน้า และปฏิบัติตามคำแนะนำ เมื่อเสร็จแล้ว คุณสามารถใช้คำสั่ง git ในเทอร์มินัลสำหรับผู้ใช้ Mac หรือพร้อมท์ให้ Anaconda ได้ Windows ผู้ใช้งาน

git clone https://github.com/PAIR-code/facets

ตัวเลือกที่ 2) ไปที่ ที่เก็บโค้ด/แง่มุม PAIR และดาวน์โหลดที่เก็บข้อมูล

หน้าเก็บข้อมูลด้านบนมีปุ่มดาวน์โหลดที่ใช้ในตัวเลือกที่ 2 หากคุณเลือกตัวเลือกแรก ไฟล์จะไปอยู่ในโฟลเดอร์ดาวน์โหลดของคุณ คุณสามารถปล่อยให้ไฟล์ดาวน์โหลดจนเสร็จ หรือลากไฟล์ไปยังตำแหน่งอื่นก็ได้

คุณสามารถตรวจสอบตำแหน่งที่เก็บ Facets ได้ด้วยบรรทัดคำสั่งนี้:

echo `pwd`/`ls facets`

เมื่อคุณพบ Facets แล้ว คุณจะต้องติดตั้งมันเข้าไป Jupyter สมุดบันทึก. คุณต้องตั้งค่าไดเร็กทอรีการทำงานให้เป็นเส้นทางที่มี facets อยู่

ไดเร็กทอรีการทำงานปัจจุบันและตำแหน่งของ Facets zip ควรเหมือนกัน

รายการคำสั่งในเทอร์มินัลด้านบนยืนยันว่า Facet อยู่ในไดเร็กทอรีการทำงานปัจจุบัน คุณต้องชี้ไดเร็กทอรีการทำงานไปยัง Facet:

cd facets

หากต้องการติดตั้ง Facets ใน Jupyterคุณมีสองทางเลือก หากคุณติดตั้ง Jupyter ด้วย Conda สำหรับผู้ใช้ทุกคน ให้คัดลอกโค้ดนี้:

jupyter nbextension install facets-dist/

มิฉะนั้นให้ใช้:

jupyter nbextension install facets-dist/ --user

เอาล่ะ คุณพร้อมแล้ว มาเปิดภาพรวม Facet กันดีกว่า

ภาพรวมฟีเจอร์การเรียกใช้ใน Jupyter

ภาพรวมใช้ Python สคริปต์สำหรับคำนวณสถิติ คุณต้องนำเข้าสคริปต์ที่ชื่อ generic_feature_statistics_generator เข้ามา Jupyter- ไม่ต้องกังวล; สคริปต์อยู่ในไฟล์ facets

คุณต้องค้นหาเส้นทางของมัน มันทำได้ง่าย คุณเปิด facets เปิดไฟล์ facets_overview จากนั้นเปิด python คัดลอกเส้นทาง

หลังจากนั้นให้กลับไปที่ Jupyterแล้วเขียนโค้ดต่อไปนี้ เปลี่ยนเส้นทาง '/Users/Thomas/facets/facets_overview/python' เป็นเส้นทางของคุณ

# Add the facets overview python code to the python path# Add t 
import sys
sys.path.append('/Users/Thomas/facets/facets_overview/python')

คุณสามารถนำเข้าสคริปต์ด้วยรหัสด้านล่าง

from generic_feature_statistics_generator import 
GenericFeatureStatisticsGenerator

ใน Windows รหัสเดียวกันจะกลายเป็น

import sys
sys.path.append(r"C:\Users\Admin\Anaconda3\facets-master\facets_overview\python")

from generic_feature_statistics_generator import GenericFeatureStatisticsGenerator

ในการคำนวณสถิติฟีเจอร์ คุณต้องใช้ฟังก์ชัน GenericFeatureStatisticsGenerator() และคุณใช้วัตถุ ProtoFromDataFrames คุณสามารถส่งผ่านกรอบข้อมูลในพจนานุกรมได้ เช่น ถ้าเราต้องการสร้างสถิติสรุปสำหรับชุดรถไฟ เราสามารถเก็บข้อมูลไว้ในพจนานุกรมและนำไปใช้ในอ็อบเจ็กต์ `ProtoFromDataFrames“

'name': 'train', 'table': df_train

ชื่อ คือชื่อของตารางที่แสดง และคุณใช้ชื่อของตารางที่คุณต้องการคำนวณสรุป ในตัวอย่างของคุณ ตารางที่มีข้อมูลคือ df_train

# Calculate the feature statistics proto from the datasets and stringify it for use in facets overview
import base64

gfsg = GenericFeatureStatisticsGenerator()

proto = gfsg.ProtoFromDataFrames([{'name': 'train', 'table': df_train},
                                  {'name': 'test', 'table': df_test}])

#proto = gfsg.ProtoFromDataFrames([{'name': 'train', 'table': df_train}])
protostr = base64.b64encode(proto.SerializeToString()).decode("utf-8")

สุดท้าย คุณเพียงแค่คัดลอกและวางโค้ดด้านล่างนี้ รหัสมาจาก GitHub โดยตรง คุณควรจะเห็นสิ่งนี้:

# Display the facets overview visualization for this data# Displ 
from IPython.core.display import display, HTML

HTML_TEMPLATE = """<link rel="import" href="/nbextensions/facets-dist/facets-jupyter.html" >
        <facets-overview id="elem"></facets-overview>
        <script>
          document.querySelector("#elem").protoInput = "{protostr}";
        </script>"""
html = HTML_TEMPLATE.format(protostr=protostr)
display(HTML(html))

กราฟความสัมพันธ์และตารางจับคู่

หลังจากตรวจสอบข้อมูลและการกระจายตัวของข้อมูลแล้ว คุณสามารถสร้างเมทริกซ์สหสัมพันธ์ได้ เมทริกซ์สหสัมพันธ์จะคำนวณค่าสัมประสิทธิ์เพียร์สัน ค่าสัมประสิทธิ์นี้จะอยู่ระหว่าง -1 และ 1 โดยค่าบวกแสดงถึงสหสัมพันธ์เชิงบวก และค่าลบแสดงถึงสหสัมพันธ์เชิงลบ

คุณสนใจที่จะดูว่าตัวแปรใดที่เป็นตัวเลือกที่ดีสำหรับเงื่อนไขการโต้ตอบ

หมายเหตุเกี่ยวกับเวอร์ชัน: หน้ากากด้านล่างเรียก np.boolซึ่งเป็นชื่อเรียกแทนที่ถูกยกเลิกการใช้งานใน NumPy เวอร์ชัน 1.20 และ ถูกลบออกใน NumPy เวอร์ชัน 1.24ใน NumPy เวอร์ชันล่าสุด บรรทัดเดียวกันนี้ทำให้เกิดข้อผิดพลาด AttributeError: module 'numpy' has no attribute 'bool'ในตัว bool สามารถใช้ทดแทนกันได้โดยตรง

## Choose important feature and further check with Dive
%matplotlib inline  
import matplotlib.pyplot as plt
import seaborn as sns
sns.set(style="ticks")
# Compute the correlation matrix
corr = df.corr('pearson')
# Generate a mask for the upper triangle
mask = np.zeros_like(corr, dtype=np.bool)
mask[np.triu_indices_from(mask)] = True
# Set up the matplotlib figure
f, ax = plt.subplots(figsize=(11, 9))

# Generate a custom diverging colormap
cmap = sns.diverging_palette(220, 10, as_cmap=True)

# Draw the heatmap with the mask and correct aspect ratio
sns.heatmap(corr, mask=mask, cmap=cmap, vmax=.3, center=0,annot=True,
            square=True, linewidths=.5, cbar_kws={"shrink": .5})

เอาท์พุต

<matplotlib.axes._subplots.AxesSubplot at 0x1a184d6518>

ในแผนภูมิความร้อนด้านบน ช่องสี่เหลี่ยมสีเข้มแสดงถึงความสัมพันธ์ที่แข็งแกร่งกว่า จากเมทริกซ์ คุณจะเห็นได้ว่า:

• LSTAT
• RM

มีความสัมพันธ์อย่างมากกับราคา อีกหนึ่งคุณสมบัติที่น่าสนใจคือ ความสัมพันธ์เชิงบวกที่แข็งแกร่งระหว่าง NOX และ INDUS ซึ่งหมายความว่าตัวแปรทั้งสองเคลื่อนไหวไปในทิศทางเดียวกัน ทั้งสองยังมีความสัมพันธ์กับราคาด้วย DIS มีความสัมพันธ์สูงกับ INDUS และ NOX เช่นกัน

คุณได้ข้อบ่งชี้เบื้องต้นแล้วว่า INDUS และ NOX อาจเป็นตัวเลือกที่ดีสำหรับพจน์ปฏิสัมพันธ์ และ DIS ก็อาจเป็นตัวแปรที่น่าสนใจที่จะพิจารณาเช่นกัน

คุณสามารถเจาะลึกลงไปได้อีกเล็กน้อยโดยการวางแผนตารางคู่ โดยจะแสดงรายละเอียดเพิ่มเติมเกี่ยวกับแผนที่ความสัมพันธ์ที่คุณวางแผนไว้ก่อนหน้านี้

ตารางจับคู่ประกอบด้วยองค์ประกอบดังต่อไปนี้:

• ส่วนบน: พล็อตกระจายพร้อมเส้นพอดี
• เส้นทแยงมุม: พล็อตความหนาแน่นของเคอร์เนล
• ส่วนล่าง: พล็อตความหนาแน่นของเคอร์เนลหลายตัวแปร

คุณให้ความสำคัญกับตัวแปรอิสระสี่ตัว โดยเลือกตัวแปรที่มีความสัมพันธ์สูงกับราคา

• อุตสาหกรรม
• NOX
• RM
• LSTAT

ยิ่งไปกว่านั้นราคา

หมายเหตุ ว่ามีการเพิ่มข้อผิดพลาดมาตรฐานลงในแผนภูมิกระจายตามค่าเริ่มต้น

attributes = ["PRICE", "INDUS", "NOX", "RM", "LSTAT"]

g = sns.PairGrid(df[attributes])
g = g.map_upper(sns.regplot, color="g")
g = g.map_lower(sns.kdeplot,cmap="Reds", shade=True, shade_lowest=False)
g = g.map_diag(sns.kdeplot)

เอาท์พุต

เริ่มจากส่วนบนกันก่อน:

• ราคามีความสัมพันธ์เชิงลบกับ INDUS, NOX และ LSTAT; มีความสัมพันธ์เชิงบวกกับ RM
• มีความไม่เป็นเชิงเส้นเล็กน้อยระหว่าง LSTAT และ PRICE
• มีลักษณะเป็นเส้นตรงเมื่อราคาเท่ากับ 50 จากคำอธิบายชุดข้อมูล PRICE ถูกตัดทอนเหลือค่า 50

เส้นทแยงมุม: NOX ดูเหมือนจะมีสองคลัสเตอร์ คลัสเตอร์หนึ่งอยู่ที่ประมาณ 0.5 และอีกคลัสเตอร์หนึ่งอยู่ที่ประมาณ 0.85

หากต้องการตรวจสอบเพิ่มเติม คุณสามารถดูได้ที่ส่วนล่าง Multivariate Kernel Density นั้นน่าสนใจในแง่ที่ว่ามันระบายสีที่จุดส่วนใหญ่ ความแตกต่างกับกราฟแบบกระจายจะวาดความหนาแน่นของความน่าจะเป็น แม้ว่าจะไม่มีจุดใดในชุดข้อมูลสำหรับพิกัดที่กำหนดก็ตาม เมื่อสีเข้มขึ้น แสดงว่าจุดต่างๆ ในบริเวณนี้เข้มข้นขึ้น

หากคุณตรวจสอบความหนาแน่นแบบหลายตัวแปรสำหรับ INDUS และ NOX คุณจะเห็นความสัมพันธ์เชิงบวกและคลัสเตอร์ทั้งสอง เมื่อส่วนแบ่งของอุตสาหกรรมอยู่เหนือ 18 ความเข้มข้นของไนตริกออกไซด์จะอยู่เหนือ 0.6

คุณสามารถคิดถึงการเพิ่มปฏิสัมพันธ์ระหว่าง INDUS และ NOX ในความสัมพันธ์เชิงเส้นได้

สุดท้ายนี้ คุณสามารถใช้เครื่องมือชิ้นที่สองที่สร้างโดย GoogleFacets Deep Dive อินเทอร์เฟซแบ่งออกเป็นสี่ส่วนหลัก ส่วนกลางเป็นพื้นที่แสดงข้อมูลที่สามารถซูมได้ ด้านบนของแผงมีเมนูแบบดรอปดาวน์ที่คุณสามารถเปลี่ยนการจัดเรียงข้อมูลเพื่อควบคุมการจัดกลุ่ม การจัดตำแหน่ง และสี ด้านขวาเป็นมุมมองรายละเอียดของแถวข้อมูลเฉพาะ คุณสามารถคลิกที่จุดข้อมูลใดก็ได้ในภาพแสดงข้อมูลตรงกลางเพื่อดูรายละเอียดเกี่ยวกับจุดข้อมูลนั้นๆ

ในขั้นตอนการสร้างภาพข้อมูล คุณมีความสนใจในการค้นหาความสัมพันธ์แบบคู่กันระหว่างตัวแปรอิสระที่มีต่อราคาบ้าน อย่างไรก็ตาม ต้องมีตัวแปรอย่างน้อยสามตัว และกราฟ 3 มิติก็ทำงานด้วยได้ยาก

วิธีหนึ่งในการแก้ปัญหานี้คือการสร้างตัวแปรเชิงหมวดหมู่ กล่าวคือ เราสามารถสร้างกราฟ 2 มิติและระบายสีจุดได้ คุณสามารถแบ่งตัวแปร PRICE ออกเป็นสี่หมวดหมู่ โดยแต่ละหมวดหมู่เป็นควอไทล์ (เช่น 0.25, 0.5, 0.75) คุณเรียกตัวแปรใหม่นี้ว่า Q_PRICE

## Check non linearity with important features
df['Q_PRICE'] =  pd.qcut(df['PRICE'], 4, labels=["Lowest", "Low", "Upper", "upper_plus"])
## Show non linearity between RM and LSTAT
ax = sns.lmplot(x="DIS", y="INDUS", hue="Q_PRICE", data=df, fit_reg = False,palette="Set3")

การใช้ Facets Deep Dive

ในการเปิดใช้งาน Deep Dive คุณต้องแปลงข้อมูลให้อยู่ในรูปแบบ JSON ก่อน Pandas มีเมธอดสำหรับทำเช่นนั้น โดยเรียกใช้เมธอด `to_json` บน DataFrame

บรรทัดแรกของโค้ดจะกำหนดขนาดของสไปรต์ตามจำนวนแถวของชุดข้อมูล

df['Q_PRICE'] =  pd.qcut(df['PRICE'], 4, labels=["Lowest", "Low", "Upper", "upper_plus"])
sprite_size = 32 if len(df.index)>50000 else 64
jsonstr = df.to_json(orient='records')

โค้ดด้านล่างนี้มาจาก Google GitHub หลังจากรันโค้ดแล้ว คุณควรจะเห็นสิ่งนี้:

# Display thde Dive visualization for this data
from IPython.core.display import display, HTML

# Create Facets template  
HTML_TEMPLATE = """<link rel="import" href="/nbextensions/facets-dist/facets-jupyter.html">
        <facets-dive sprite-image-width="{sprite_size}" sprite-image-height="{sprite_size}" id="elem" height="600"></facets-dive>
        <script>
          document.querySelector("#elem").data = {jsonstr};
        </script>"""

# Load the json dataset and the sprite_size into the template
html = HTML_TEMPLATE.format(jsonstr=jsonstr, sprite_size=sprite_size)

# Display the template
display(HTML(html))

คุณสนใจที่จะดูว่ามีความเชื่อมโยงระหว่างอัตราอุตสาหกรรม ความเข้มข้นของออกไซด์ ระยะทางไปศูนย์จัดหางาน และราคาบ้านหรือไม่

เพื่อทำเช่นนั้น ขั้นแรกให้คุณแบ่งข้อมูลตามช่วงอุตสาหกรรมและสีด้วยควอร์ไทล์ราคา:

• เลือกด้าน X และเลือก INDUS
• เลือกจอแสดงผลและเลือก DIS มันจะลงสีจุดด้วยควอไทล์ของราคาบ้าน

ในแผนภาพนี้ สีที่เข้มกว่าหมายความว่าระยะทางไปยังศูนย์จัดหางานแห่งแรกนั้นไกลกว่า

จนถึงตอนนี้ มันแสดงให้เห็นอีกครั้งถึงสิ่งที่คุณรู้ อัตราอุตสาหกรรมที่ลดลง ราคาที่สูงขึ้น ตอนนี้คุณสามารถดูรายละเอียดตาม INDUX และ NOX ได้แล้ว

เลือกด้าน Y และเลือก NOX

ตอนนี้คุณจะเห็นว่าบ้านที่อยู่ไกลจากศูนย์จัดหางานแห่งแรกมีส่วนแบ่งอุตสาหกรรมต่ำที่สุดและจึงมีความเข้มข้นของออกไซด์ต่ำที่สุด หากคุณเลือกแสดงประเภทด้วย Q_PRICE และซูมที่มุมล่างซ้าย คุณจะเห็นว่าเป็นราคาประเภทใด

คุณมีคำใบ้อีกประการหนึ่งว่าปฏิสัมพันธ์ระหว่าง IND, NOX และ DIS สามารถเป็นตัวเลือกที่ดีในการปรับปรุงโมเดล

จากการสำรวจพบปฏิสัมพันธ์ที่เป็นไปได้สองแบบ ขั้นตอนต่อไปคือการทดสอบปฏิสัมพันธ์เหล่านั้นในแบบจำลองจริง

การถดถอยเชิงเส้นด้วย TensorFlow

ในส่วนนี้ คุณจะทำการประมาณค่าแบบจำลองการถดถอยเชิงเส้นด้วย TensorFlow API สำหรับประเมินราคา โปรดดำเนินการดังต่อไปนี้:

• เตรียมข้อมูล
• ประมาณแบบจำลองเกณฑ์มาตรฐาน: ไม่มีการโต้ตอบ
• ประมาณแบบจำลองที่มีการโต้ตอบ

หมายเหตุเกี่ยวกับเวอร์ชัน: tf-estimator แพ็กเกจนี้ได้เปิดตัวเวอร์ชันสุดท้ายพร้อมกับ TensorFlow 2.15 และไม่มีอยู่ใน TensorFlow 2.16 เป็นต้นไป tf.estimator.LinearRegressor ใช้งานได้เฉพาะกับ TensorFlow 1.x เท่านั้น เว้นแต่คุณจะย้ายไปใช้โมเดลเชิงเส้นของ Keras

โปรดจำไว้ว่า เป้าหมายของการเรียนรู้ของเครื่องจักรคือการลดข้อผิดพลาดให้เหลือน้อยที่สุด ในกรณีนี้ โมเดลที่มีค่าความคลาดเคลื่อนกำลังสองเฉลี่ยต่ำที่สุดจะเป็นผู้ชนะ ตัวประมาณค่าของ TensorFlow จะคำนวณค่าเมตริกนี้โดยอัตโนมัติ

ข้อมูลการเตรียมการ

ในกรณีส่วนใหญ่ คุณจำเป็นต้องแปลงข้อมูลของคุณ นั่นคือเหตุผลที่ Facets Overview น่าสนใจ จากสถิติสรุป คุณจะเห็นค่าผิดปกติ ค่าเหล่านั้นส่งผลต่อการประมาณค่าเพราะมันดูไม่เหมือนประชากรที่คุณกำลังวิเคราะห์ ค่าผิดปกติมักทำให้ผลลัพธ์คลาดเคลื่อน ตัวอย่างเช่น ค่าผิดปกติที่เป็นบวกมักจะทำให้ค่าสัมประสิทธิ์สูงเกินจริง

วิธีแก้ปัญหาที่ดีคือการทำให้ตัวแปรเป็นค่ามาตรฐาน การทำให้เป็นค่ามาตรฐานหมายถึงค่าเบี่ยงเบนมาตรฐานเท่ากับหนึ่งและค่าเฉลี่ยเท่ากับศูนย์ กระบวนการทำให้เป็นค่ามาตรฐานประกอบด้วยสองขั้นตอน ขั้นแรกคือการแปลงค่าเบี่ยงเบนมาตรฐานให้เป็นค่าเฉลี่ยtracประการที่สอง คือค่าเฉลี่ยของตัวแปร และประการที่สอง คือหารด้วยค่าเบี่ยงเบนมาตรฐาน เพื่อให้การกระจายตัวมีค่าเบี่ยงเบนมาตรฐานเท่ากับ 1

ห้องสมุด scikit เรียนรู้ การทำให้ตัวแปรเป็นมาตรฐานนั้นมีประโยชน์ คุณสามารถใช้โมดูลการประมวลผลล่วงหน้าด้วยมาตราส่วนของวัตถุเพื่อจุดประสงค์นี้ได้

คุณสามารถใช้ฟังก์ชันด้านล่างเพื่อปรับขนาดชุดข้อมูลได้ โปรดทราบว่าคุณไม่ได้ปรับขนาดคอลัมน์ป้ายกำกับและตัวแปรหมวดหมู่

from sklearn import preprocessing
def standardize_data(df): 
    X_scaled = preprocessing.scale(df[['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD',
       'TAX', 'PTRATIO', 'B', 'LSTAT']])
    X_scaled_df = pd.DataFrame(X_scaled, columns = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD',
       'TAX', 'PTRATIO', 'B', 'LSTAT'])
    df_scale = pd.concat([X_scaled_df,
                       df['CHAS'],
                       df['PRICE']],axis=1, join='inner')
    return df_scale

คุณสามารถใช้ฟังก์ชันนี้เพื่อสร้างชุดรถไฟ/ชุดทดสอบที่ปรับขนาดได้

df_train_scale = standardize_data(df_train)
df_test_scale = standardize_data(df_test)

การถดถอยพื้นฐาน:เกณฑ์มาตรฐาน

ก่อนอื่น คุณฝึกและทดสอบโมเดลโดยไม่มีการโต้ตอบ จุดประสงค์คือการดูตัวชี้วัดประสิทธิภาพของแบบจำลอง

วิธีการฝึกโมเดลนั้นเหมือนกับในบทช่วยสอนทุกประการ API ระดับสูง- คุณจะใช้ตัวประมาณค่า TensorFlow LinearRegressor

เพื่อเป็นการเตือนความจำ คุณต้องเลือก:

• คุณสมบัติที่จะใส่ในโมเดล
• เปลี่ยนคุณสมบัติ
• สร้างตัวถดถอยเชิงเส้น
• สร้างฟังก์ชัน input_fn
• ฝึกโมเดล
• ทดสอบโมเดล

คุณใช้ตัวแปรทั้งหมดในชุดข้อมูลเพื่อฝึกฝนโมเดล โดยรวมแล้วมีตัวแปรต่อเนื่องสิบสองตัวและตัวแปรเชิงหมวดหมู่หนึ่งตัว

## Add features to the bucket: 
### Define continuous list
CONTI_FEATURES  = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT']
CATE_FEATURES = ['CHAS']

คุณแปลงคุณลักษณะเป็นคอลัมน์ตัวเลขหรือคอลัมน์ประเภท

continuous_features = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES]
#categorical_features = tf.feature_column.categorical_column_with_hash_bucket(CATE_FEATURES, hash_bucket_size=1000)
categorical_features = [tf.feature_column.categorical_column_with_vocabulary_list('CHAS', ['yes','no'])]

คุณสร้างโมเดลด้วย linearRegressor คุณเก็บโมเดลไว้ในโฟลเดอร์ train_Boston

model = tf.estimator.LinearRegressor(    
	model_dir="train_Boston",     
    feature_columns=categorical_features + continuous_features)

เอาท์พุต

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'train_Boston', '_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 0x1a19e76ac8>, '_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}

แต่ละคอลัมน์ในข้อมูลฝึกฝนหรือข้อมูลทดสอบจะถูกแปลงเป็นเทนเซอร์โดยใช้ฟังก์ชัน get_input_fn

FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT', 'CHAS']
LABEL= 'PRICE'
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)

คุณประมาณแบบจำลองจากข้อมูลรถไฟ

model.train(input_fn=get_input_fn(df_train_scale, 
                                      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_Boston/model.ckpt.
INFO:tensorflow:loss = 56417.703, step = 1
INFO:tensorflow:global_step/sec: 144.457
INFO:tensorflow:loss = 76982.734, step = 101 (0.697 sec)
INFO:tensorflow:global_step/sec: 258.392
INFO:tensorflow:loss = 21246.334, step = 201 (0.383 sec)
INFO:tensorflow:global_step/sec: 227.998
INFO:tensorflow:loss = 30534.78, step = 301 (0.439 sec)
INFO:tensorflow:global_step/sec: 210.739
INFO:tensorflow:loss = 36794.5, step = 401 (0.477 sec)
INFO:tensorflow:global_step/sec: 234.237
INFO:tensorflow:loss = 8562.981, step = 501 (0.425 sec)
INFO:tensorflow:global_step/sec: 238.1
INFO:tensorflow:loss = 34465.08, step = 601 (0.420 sec)
INFO:tensorflow:global_step/sec: 237.934
INFO:tensorflow:loss = 12241.709, step = 701 (0.420 sec)
INFO:tensorflow:global_step/sec: 220.687
INFO:tensorflow:loss = 11019.228, step = 801 (0.453 sec)
INFO:tensorflow:global_step/sec: 232.702
INFO:tensorflow:loss = 24049.678, step = 901 (0.432 sec)
INFO:tensorflow:Saving checkpoints for 1000 into train_Boston/model.ckpt.
INFO:tensorflow:Loss for final step: 23228.568.


<tensorflow.python.estimator.canned.linear.LinearRegressor at 0x1a19e76320>

ในที่สุดคุณก็ประเมินประสิทธิภาพของแบบจำลองบนชุดทดสอบ

model.evaluate(input_fn=get_input_fn(df_test_scale, 
                                      num_epochs=1,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)

เอาท์พุต

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-05-29-02:40:43
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train_Boston/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-05-29-02:40:43
INFO:tensorflow:Saving dict for global step 1000: average_loss = 86.89361, global_step = 1000, loss = 1650.9785


{'average_loss': 86.89361, 'global_step': 1000, 'loss': 1650.9785}

หลุดโมเดลอยู่ที่ 1650.9785 นี่คือตัวชี้วัดที่ต้องเอาชนะในส่วนถัดไป

ปรับปรุงโมเดล: เงื่อนไขการโต้ตอบ

ในส่วนแรกของบทเรียน คุณได้เห็นความสัมพันธ์ที่น่าสนใจระหว่างตัวแปรต่างๆ เทคนิคการแสดงภาพข้อมูลที่แตกต่างกันเผยให้เห็นว่า INDUS และ NOX เชื่อมโยงกันและเสริมผลกระทบซึ่งกันและกันต่อราคา ไม่เพียงแต่ปฏิสัมพันธ์ระหว่าง INDUS และ NOX จะส่งผลต่อราคาเท่านั้น แต่ผลกระทบนี้จะยิ่งรุนแรงขึ้นเมื่อมีปฏิสัมพันธ์กับ DIS ด้วย

ถึงเวลาที่จะนำแนวคิดนี้ไปประยุกต์ใช้และดูว่าคุณสามารถปรับปรุงการทำนายของแบบจำลองได้หรือไม่

คุณต้องเพิ่มคอลัมน์ใหม่สองคอลัมน์ให้กับแต่ละชุดข้อมูล ได้แก่ ชุดข้อมูลฝึกฝน (train) และชุดข้อมูลทดสอบ (test) โดยสร้างฟังก์ชันหนึ่งเพื่อคำนวณพจน์ปฏิสัมพันธ์ และอีกฟังก์ชันหนึ่งเพื่อคำนวณพจน์ปฏิสัมพันธ์แบบสามเท่า (triple interaction term) แต่ละฟังก์ชันจะสร้างคอลัมน์เดียว หลังจากสร้างตัวแปรใหม่แล้ว คุณสามารถนำตัวแปรเหล่านั้นไปต่อเข้ากับชุดข้อมูลฝึกฝนและชุดข้อมูลทดสอบได้

ก่อนอื่น คุณต้องสร้างตัวแปรใหม่สำหรับการโต้ตอบระหว่าง INDUS และ NOX

ฟังก์ชันด้านล่างส่งคืนสอง dataframes ฝึกและทดสอบ โดยมีการโต้ตอบระหว่าง var_1 และ var_2 ในกรณีของคุณ INDUS และ NOX

def interaction_term(var_1, var_2, name):
    t_train = df_train_scale[var_1]*df_train_scale[var_2]
    train = t_train.rename(name)
    t_test = df_test_scale[var_1]*df_test_scale[var_2]
    test = t_test.rename(name)
    return train, test

คุณเก็บคอลัมน์ใหม่สองคอลัมน์

interation_ind_ns_train, interation_ind_ns_test= interaction_term('INDUS', 'NOX', 'INDUS_NOS')
interation_ind_ns_train.shape
(325,)

ประการที่สอง คุณสร้างฟังก์ชันที่สองเพื่อคำนวณเงื่อนไขการโต้ตอบสามคำ

def triple_interaction_term(var_1, var_2,var_3, name):
    t_train = df_train_scale[var_1]*df_train_scale[var_2]*df_train_scale[var_3]
    train = t_train.rename(name)
    t_test = df_test_scale[var_1]*df_test_scale[var_2]*df_test_scale[var_3]
    test = t_test.rename(name)
    return train, test
interation_ind_ns_dis_train, interation_ind_ns_dis_test= triple_interaction_term('INDUS', 'NOX', 'DIS','INDUS_NOS_DIS')

เมื่อคุณมีคอลัมน์ทั้งหมดที่จำเป็นแล้ว คุณสามารถเพิ่มคอลัมน์เหล่านั้นเพื่อฝึกและทดสอบชุดข้อมูลได้ คุณตั้งชื่อ dataframe ใหม่ทั้งสองนี้:

• df_train_new
• df_test_new

df_train_new = pd.concat([df_train_scale,
                          interation_ind_ns_train,
                          interation_ind_ns_dis_train],
                         axis=1, join='inner')
df_test_new = pd.concat([df_test_scale,
                         interation_ind_ns_test,
                         interation_ind_ns_dis_test],
                         axis=1, join='inner')
df_train_new.head(5)

เอาท์พุต

แค่นั้นเอง: คุณสามารถประมาณค่าโมเดลใหม่โดยใช้พารามิเตอร์ปฏิสัมพันธ์และดูว่าตัวชี้วัดประสิทธิภาพเป็นอย่างไร

CONTI_FEATURES_NEW  = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT',
                       'INDUS_NOS', 'INDUS_NOS_DIS']
### Define categorical list
continuous_features_new = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES_NEW]
model = tf.estimator.LinearRegressor(
    model_dir="train_Boston_1", 
    feature_columns= categorical_features + continuous_features_new)

เอาท์พุต

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'train_Boston_1', '_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 0x1a1a5d5860>, '_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}

Code

FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT','INDUS_NOS', 'INDUS_NOS_DIS','CHAS']
LABEL= 'PRICE'
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)

model.train(input_fn=get_input_fn(df_train_new, 
                                      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_Boston_1/model.ckpt.
INFO:tensorflow:loss = 56417.703, step = 1
INFO:tensorflow:global_step/sec: 124.844
INFO:tensorflow:loss = 65522.3, step = 101 (0.803 sec)
INFO:tensorflow:global_step/sec: 182.704
INFO:tensorflow:loss = 15384.148, step = 201 (0.549 sec)
INFO:tensorflow:global_step/sec: 208.189
INFO:tensorflow:loss = 22020.305, step = 301 (0.482 sec)
INFO:tensorflow:global_step/sec: 213.855
INFO:tensorflow:loss = 28208.812, step = 401 (0.468 sec)
INFO:tensorflow:global_step/sec: 209.758
INFO:tensorflow:loss = 7606.877, step = 501 (0.473 sec)
INFO:tensorflow:global_step/sec: 196.618
INFO:tensorflow:loss = 26679.76, step = 601 (0.514 sec)
INFO:tensorflow:global_step/sec: 196.472
INFO:tensorflow:loss = 11377.163, step = 701 (0.504 sec)
INFO:tensorflow:global_step/sec: 172.82
INFO:tensorflow:loss = 8592.07, step = 801 (0.578 sec)
INFO:tensorflow:global_step/sec: 168.916
INFO:tensorflow:loss = 19878.56, step = 901 (0.592 sec)
INFO:tensorflow:Saving checkpoints for 1000 into train_Boston_1/model.ckpt.
INFO:tensorflow:Loss for final step: 19598.387.


<tensorflow.python.estimator.canned.linear.LinearRegressor at 0x1a1a5d5e10>

model.evaluate(input_fn=get_input_fn(df_test_new, 
                                      num_epochs=1,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)

เอาท์พุต

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-05-29-02:41:14
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train_Boston_1/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-05-29-02:41:14
INFO:tensorflow:Saving dict for global step 1000: average_loss = 79.78876, global_step = 1000, loss = 1515.9863


{'average_loss': 79.78876, 'global_step': 1000, 'loss': 1515.9863}

ขาดทุนใหม่คือ 1515.9863 เพียงเพิ่มตัวแปรใหม่สองตัว คุณก็สามารถลดการขาดทุนได้ หมายความว่าคุณสามารถคาดการณ์ได้ดีกว่าแบบจำลองการวัดประสิทธิภาพ

ตัวเลขทั้งสองมาจากชุดข้อมูลทดสอบ 101 แถวชุดเดียวกัน ดังนั้นการลดลงของค่าเฉลี่ยประมาณ 8 เปอร์เซ็นต์จึงเกิดจากคอลัมน์ปฏิสัมพันธ์ทั้งสองคอลัมน์เพียงอย่างเดียว

คำถามที่พบบ่อย