การเรียนรู้ของเครื่องสำหรับนักพัฒนา Java ตอนที่ 1
การประมาณค่าฟังก์ชันวัตถุประสงค์
ให้เราระลึกว่าฟังก์ชันเป้าหมาย
hθ
หรือที่เรียกว่าฟังก์ชันการทำนาย เป็นผลมาจากกระบวนการเตรียมการหรือการฝึกอบรม ความท้าทายทางคณิตศาสตร์คือการหาฟังก์ชันที่รับตัวแปรเป็นอินพุต
х
และส่งคืนค่าที่คาดการณ์
у
ไว้
ในการเรียนรู้ของเครื่อง ฟังก์ชันต้นทุน
(J(θ))
ใช้ในการคำนวณค่าความผิดพลาดหรือ "ต้นทุน" ของฟังก์ชันวัตถุประสงค์ที่กำหนด
ฟังก์ชันต้นทุนแสดงให้เห็นว่าแบบจำลองเหมาะสมกับข้อมูลการฝึกได้ดีเพียงใด
(i)
ในการกำหนดต้นทุนของฟังก์ชันวัตถุประสงค์ที่แสดงข้าง ต้นจำเป็นต้องคำนวณค่าคลาดเคลื่อนกำลังสองของบ้านตัวอย่างแต่ละหลัง Error คือระยะห่างระหว่างค่าที่คำนวณ
у
ได้กับมูลค่าที่แท้จริง
y
ของบ้านจากตัวอย่าง
i
ตัวอย่างเช่น ราคาจริงของบ้านที่มีพื้นที่
1330 = 6,500,000 € . และความแตกต่างระหว่างราคาบ้านที่คาดการณ์โดยฟังก์ชันวัตถุประสงค์ที่ได้รับการฝึกคือ
€7,032,478 : ส่วนต่าง (หรือข้อผิดพลาด) คือ
€ 532,478 คุณยังสามารถเห็นความแตกต่างนี้ได้ในกราฟด้านบน ส่วนต่าง (หรือข้อผิดพลาด) จะแสดงเป็นเส้นประสีแดงแนวตั้งสำหรับคู่การฝึกพื้นที่ราคาแต่ละคู่ เมื่อคำนวณต้นทุนของฟังก์ชันวัตถุประสงค์ที่ได้รับการฝึกแล้ว คุณจะต้องรวมค่าคลาดเคลื่อนกำลังสองสำหรับแต่ละบ้านในตัวอย่างและคำนวณค่าหลัก ยิ่งค่าราคาน้อยลง
(J(θ))
การทำนายฟังก์ชันวัตถุประสงค์ของเราก็จะยิ่งแม่นยำมากขึ้นเท่านั้น รายการ
3แสดงการใช้งาน Java อย่างง่ายของฟังก์ชันต้นทุนที่รับเป็นอินพุตของฟังก์ชันวัตถุประสงค์ รายการข้อมูลการฝึก และป้ายกำกับที่เกี่ยวข้อง ค่าทำนายจะถูกคำนวณแบบวนซ้ำและข้อผิดพลาดจะคำนวณโดยการลบมูลค่าราคาจริง (นำมาจากฉลาก) ต่อมาจะมีการรวมกำลังสองของข้อผิดพลาดและคำนวณค่าความผิดพลาด ต้นทุนจะถูกส่งกลับเป็นค่าประเภท
double
:
รายการ-3
public static double cost(Function<ltDouble[], Double> targetFunction,
List<ltDouble[]> dataset,
List<ltDouble> labels) {
int m = dataset.size();
double sumSquaredErrors = 0;
for (int i = 0; i < m; i++) {
Double[] featureVector = dataset.get(i);
double predicted = targetFunction.apply(featureVector);
double label = labels.get(i);
double gap = predicted - label;
sumSquaredErrors += Math.pow(gap, 2);
}
return (1.0 / (2 * m)) * sumSquaredErrors;
}
การเรียนรู้ฟังก์ชั่นเป้าหมาย
แม้ว่าฟังก์ชันต้นทุนจะช่วยประเมินคุณภาพของฟังก์ชันเป้าหมายและพารามิเตอร์ทีต้า แต่คุณยังคงต้องหาพารามิเตอร์ทีต้าที่เหมาะสมที่สุด คุณสามารถใช้อัลกอริธึมการไล่ระดับสีสำหรับสิ่งนี้
การไล่ระดับโคตร
การไล่ระดับสีจะช่วยลดฟังก์ชันต้นทุนให้เหลือน้อยที่สุด ซึ่งหมายความว่าจะใช้เพื่อค้นหาพารามิเตอร์ทีต้าที่มีต้นทุนขั้นต่ำ
(J(θ))
ตามข้อมูลการฝึกอบรม ต่อไปนี้เป็นอัลกอริทึมแบบง่ายสำหรับการคำนวณค่าทีต้าใหม่ที่เหมาะสมยิ่งขึ้น:
ดังนั้น พารามิเตอร์ของเวกเตอร์ทีต้าจะดีขึ้นเมื่อมีการวนซ้ำอัลกอริทึมแต่ละครั้ง ค่าสัมประสิทธิ์การเรียนรู้ α ระบุจำนวนการคำนวณในการวนซ้ำแต่ละครั้ง การคำนวณเหล่านี้สามารถดำเนินการได้จนกว่าจะพบค่าทีต้า "ดี" ตัวอย่างเช่น ฟังก์ชันการถดถอยเชิงเส้นด้านล่างมีพารามิเตอร์ทีต้าสามตัว:
ในการวนซ้ำแต่ละครั้ง ค่าใหม่จะถูกคำนวณสำหรับพารามิเตอร์ทีต้าแต่ละตัว: , และ หลังจากการวนซ้ำแต่ละครั้ง คุณสามารถสร้างการใช้งานใหม่ที่เหมาะสมยิ่งขึ้นได้โดยใช้เวกเตอร์ทีต้าใหม่{
θ 0 , θ 1 , θ 2 } รายการ
-4แสดงโค้ด Java สำหรับอัลกอริธึมการสลายการไล่ระดับสี ทีต้าสำหรับฟังก์ชันการถดถอยจะได้รับการฝึกโดยใช้ข้อมูลการฝึก ข้อมูลเครื่องหมาย อัตราการเรียนรู้ ผลลัพธ์จะเป็นฟังก์ชันวัตถุประสงค์ที่ได้รับการปรับปรุงโดยใช้พารามิเตอร์ทีต้า วิธีการนี้จะถูกเรียกครั้งแล้วครั้งเล่า โดยผ่านฟังก์ชันวัตถุประสงค์ใหม่และพารามิเตอร์ทีต้าใหม่จากการคำนวณครั้งก่อน และการเรียกเหล่านี้จะถูกทำซ้ำจนกว่าฟังก์ชันวัตถุประสงค์ที่กำหนดค่าไว้จะถึงจุดต่ำสุด:
θ0
θ1
θ2
LinearRegressionFunction
(α)
train()
รายการ-4
public static LinearRegressionFunction train(LinearRegressionFunction targetFunction,
List<ltDouble[]> dataset,
List<ltDouble> labels,
double alpha) {
int m = dataset.size();
double[] thetaVector = targetFunction.getThetas();
double[] newThetaVector = new double[thetaVector.length];
for (int j = 0; j < thetaVector.length; j++) {
double sumErrors = 0;
for (int i = 0; i < m; i++) {
Double[] featureVector = dataset.get(i);
double error = targetFunction.apply(featureVector) - labels.get(i);
sumErrors += error * featureVector[j];
}
double gradient = (1.0 / m) * sumErrors;
newThetaVector[j] = thetaVector[j] - alpha * gradient;
}
return new LinearRegressionFunction(newThetaVector);
}
เพื่อให้แน่ใจว่าต้นทุนลดลงอย่างต่อเนื่อง คุณสามารถรันฟังก์ชันต้นทุนได้
J(θ)
หลังจากแต่ละขั้นตอนการฝึกอบรม หลังจากทำซ้ำแต่ละครั้ง ต้นทุนควรจะลดลง หากไม่เกิดขึ้น แสดงว่าค่าสัมประสิทธิ์การเรียนรู้สูงเกินไป และอัลกอริทึมพลาดค่าต่ำสุดไป ในกรณีเช่นนี้ อัลกอริธึมการสลายการไล่ระดับสีจะล้มเหลว แผนภาพด้านล่างแสดงฟังก์ชันวัตถุประสงค์โดยใช้พารามิเตอร์ทีต้าใหม่ที่คำนวณได้ โดยเริ่มจากเวกเตอร์ทีต้าเริ่ม
{1.0, 1.0}
ต้น คอลัมน์ด้านซ้ายแสดงพล็อตของฟังก์ชันการทำนายหลังจากการวนซ้ำ 50 ครั้ง คอลัมน์กลางหลังจากทำซ้ำ 200 ครั้ง และคอลัมน์ด้านขวาหลังจากทำซ้ำ 1,000 ครั้ง จากสิ่งเหล่านี้ เราจะเห็นว่าราคาลดลงหลังจากการวนซ้ำแต่ละครั้ง และฟังก์ชันวัตถุประสงค์ใหม่เข้ากันได้ดีขึ้นเรื่อยๆ หลังจากการทำซ้ำ 500-600 ครั้ง พารามิเตอร์ทีต้าจะไม่เปลี่ยนแปลงอย่างมีนัยสำคัญอีกต่อไป และราคาถึงจุดคงที่ หลังจากนี้ ความแม่นยำของฟังก์ชันเป้าหมายไม่สามารถปรับปรุงได้ในลักษณะนี้
ในกรณีนี้ แม้ว่าต้นทุนจะไม่ลดลงอย่างมีนัยสำคัญอีกต่อไปหลังจากการวนซ้ำ 500-600 ครั้ง แต่ฟังก์ชันวัตถุประสงค์ยังคงไม่เหมาะสมที่สุด สิ่งนี้บ่งบอกถึง
ความคลาดเคลื่อน ในการเรียนรู้ของเครื่อง คำว่า "ความไม่สอดคล้องกัน" ใช้เพื่อระบุว่าอัลกอริทึมการเรียนรู้ไม่พบแนวโน้มที่ซ่อนอยู่ในข้อมูล จากประสบการณ์จริง มีแนวโน้มว่าราคาต่อตารางเมตรสำหรับอสังหาริมทรัพย์ขนาดใหญ่จะลดลง จากนี้เราสามารถสรุปได้ว่าแบบจำลองที่ใช้สำหรับกระบวนการเรียนรู้ฟังก์ชันเป้าหมายไม่พอดีกับข้อมูลเพียงพอ ความคลาดเคลื่อนมักเกิดจากการทำให้โมเดลเรียบง่ายเกินไป สิ่งนี้เกิดขึ้นในกรณีของเรา ฟังก์ชั่นวัตถุประสงค์นั้นง่ายเกินไป และสำหรับการวิเคราะห์นั้นจะใช้พารามิเตอร์ตัวเดียว - พื้นที่ของบ้าน แต่ข้อมูลนี้ไม่เพียงพอที่จะทำนายราคาบ้านได้อย่างแม่นยำ
การเพิ่มคุณสมบัติและการปรับขนาด
หากคุณพบว่าฟังก์ชันวัตถุประสงค์ของคุณไม่สอดคล้องกับปัญหาที่คุณพยายามแก้ไข จำเป็นต้องปรับเปลี่ยนฟังก์ชันดังกล่าว วิธีทั่วไปในการแก้ไขความไม่สอดคล้องกันคือการเพิ่มคุณลักษณะเพิ่มเติมให้กับเวกเตอร์คุณลักษณะ ในตัวอย่างราคาบ้าน คุณสามารถเพิ่มลักษณะเฉพาะ เช่น จำนวนห้อง หรืออายุของบ้านได้ นั่นคือ แทนที่จะใช้เวกเตอร์ที่มีค่าคุณลักษณะเดียว
{size}
เพื่ออธิบายบ้าน คุณสามารถใช้เวกเตอร์ที่มีหลายค่าได้ ตัวอย่างเช่น
{size, number-of-rooms, age}.
ในบางกรณี จำนวนคุณลักษณะในข้อมูลการฝึกอบรมที่มีอยู่ยังไม่เพียงพอ ถ้าอย่างนั้นก็คุ้มค่าที่จะลองใช้คุณสมบัติพหุนามที่คำนวณโดยใช้คุณสมบัติที่มีอยู่ ตัวอย่างเช่น คุณมีโอกาสที่จะขยายฟังก์ชันวัตถุประสงค์ในการกำหนดราคาบ้านเพื่อให้รวมคุณลักษณะที่คำนวณได้เป็นตารางเมตร (x2):
การใช้คุณลักษณะหลายรายการจำเป็นต้องมี
การปรับขนาดคุณลักษณะซึ่งใช้เพื่อกำหนดช่วงของคุณลักษณะต่างๆ ให้เป็นมาตรฐาน ดังนั้นช่วงของค่าสำหรับ แอตทริบิวต์
ขนาด2จึงมากกว่าช่วงของค่าสำหรับแอตทริบิวต์ขนาดอย่างมาก หากไม่มีการปรับขนาดคุณลักษณะ
ขนาด2จะส่งผลต่อฟังก์ชันต้นทุนอย่างไม่เหมาะสม ข้อผิดพลาดที่เกิดจาก แอตทริบิวต์
ขนาด2จะมากกว่าข้อผิดพลาดที่เกิดจากแอตทริบิวต์ขนาดอย่างมาก อัลกอริธึมการปรับขนาดคุณสมบัติอย่างง่ายมีดังต่อไปนี้:
อัลกอริทึมนี้ถูกนำไปใช้ในคลาส
FeaturesScaling
ในโค้ดตัวอย่างด้านล่าง ชั้นเรียน
FeaturesScaling
นำเสนอวิธีการเชิงพาณิชย์สำหรับการสร้างฟังก์ชันการปรับขนาดที่ปรับให้เข้ากับข้อมูลการฝึก ภายใน อินสแตนซ์ข้อมูลการฝึกอบรมจะใช้ในการคำนวณค่าเฉลี่ย ค่าต่ำสุด และค่าสูงสุด ฟังก์ชันผลลัพธ์จะใช้เวกเตอร์คุณลักษณะและสร้างเวกเตอร์ใหม่ที่มีคุณสมบัติปรับขนาด การปรับขนาดคุณสมบัติเป็นสิ่งจำเป็นสำหรับทั้งกระบวนการเรียนรู้และกระบวนการทำนาย ดังที่แสดงด้านล่าง:
List<ltDouble[]> dataset = new ArrayList<>();
dataset.add(new Double[] { 1.0, 90.0, 8100.0 });
dataset.add(new Double[] { 1.0, 101.0, 10201.0 });
dataset.add(new Double[] { 1.0, 103.0, 10609.0 });
List<ltDouble> labels = new ArrayList<>();
labels.add(249.0);
labels.add(338.0);
labels.add(304.0);
Function<ltDouble[], Double[]> scalingFunc = FeaturesScaling.createFunction(dataset);
List<ltDouble[]> scaledDataset = dataset.stream().map(scalingFunc).collect(Collectors.toList());
LinearRegressionFunction targetFunction = new LinearRegressionFunction(new double[] { 1.0, 1.0, 1.0 });
for (int i = 0; i < 10000; i++) {
targetFunction = Learner.train(targetFunction, scaledDataset, labels, 0.1);
}
Double[] scaledFeatureVector = scalingFunc.apply(new Double[] { 1.0, 600.0, 360000.0 });
double predictedPrice = targetFunction.apply(scaledFeatureVector);
เมื่อมีการเพิ่มคุณสมบัติต่างๆ มากขึ้น ความเหมาะสมกับฟังก์ชั่นวัตถุประสงค์ก็จะเพิ่มขึ้น แต่ต้องระวังด้วย หากคุณทำมากเกินไปและเพิ่มคุณสมบัติมากเกินไป คุณอาจได้เรียนรู้ฟังก์ชันวัตถุประสงค์ที่มากเกินไป
การจับคู่มากเกินไปและการตรวจสอบข้าม
การติดตั้งมากเกินไปเกิดขึ้นเมื่อฟังก์ชันวัตถุประสงค์หรือแบบจำลองเหมาะสมกับข้อมูลการฝึกมากเกินไป มากจนสามารถจับสัญญาณรบกวนหรือการเปลี่ยนแปลงแบบสุ่มในข้อมูลการฝึกได้ ตัวอย่างของการโอเวอร์ฟิตจะแสดงอยู่ในกราฟด้านขวาสุดด้านล่าง:
อย่างไรก็ตาม โมเดลการโอเวอร์ฟิตจะทำงานได้ดีมากกับข้อมูลการฝึก แต่จะทำงานได้ไม่ดีกับข้อมูลที่ไม่รู้จักจริง มีหลายวิธีในการหลีกเลี่ยงการสวมใส่มากเกินไป
- ใช้ชุดข้อมูลที่ใหญ่กว่าสำหรับการฝึก
- ใช้ฟีเจอร์น้อยลงตามที่แสดงในกราฟด้านบน
- ใช้อัลกอริธึมการเรียนรู้ของเครื่องที่ได้รับการปรับปรุงซึ่งคำนึงถึงการทำให้เป็นมาตรฐาน
หากอัลกอริธึมการคาดการณ์เหมาะสมกับข้อมูลการฝึก จำเป็นต้องกำจัดคุณสมบัติที่ไม่เป็นประโยชน์ต่อความแม่นยำ ความยากคือการค้นหาคุณลักษณะที่มีผลกระทบอย่างมีนัยสำคัญต่อความแม่นยำในการทำนายมากกว่าคุณลักษณะอื่นๆ ดังที่แสดงในกราฟ สามารถกำหนดโอเวอร์ฟิตด้วยสายตาได้โดยใช้กราฟ วิธีนี้ใช้ได้ผลดีกับกราฟที่มีพิกัด 2 หรือ 3 พิกัด การลงจุดและประเมินกราฟจะเป็นเรื่องยากหากคุณใช้คุณลักษณะมากกว่า 2 รายการ ในการตรวจสอบความถูกต้องข้าม คุณจะทดสอบโมเดลอีกครั้งหลังการฝึกโดยใช้ข้อมูลที่อัลกอริธึมไม่รู้จักหลังจากกระบวนการฝึกเสร็จสิ้น ข้อมูลป้ายกำกับที่มีอยู่ควรแบ่งออกเป็น 3 ชุด:
- ข้อมูลการฝึกอบรม
- ข้อมูลการตรวจสอบ
- ข้อมูลการทดสอบ
ในกรณีนี้ 60 เปอร์เซ็นต์ของบันทึกที่มีป้ายกำกับซึ่งระบุลักษณะบ้านควรใช้ในกระบวนการฝึกอบรมตัวแปรต่างๆ ของอัลกอริธึมเป้าหมาย หลังจากกระบวนการฝึกอบรม ควรใช้ข้อมูลที่เหลือครึ่งหนึ่ง (ไม่เคยใช้ก่อนหน้านี้) เพื่อตรวจสอบว่าอัลกอริทึมเป้าหมายที่ได้รับการฝึกอบรมทำงานได้ดีกับข้อมูลที่ไม่รู้จัก โดยทั่วไปแล้ว อัลกอริธึมที่ทำงานได้ดีกว่าอัลกอริธึมอื่นๆ จะถูกเลือกมาใช้งาน ข้อมูลที่เหลือจะใช้ในการคำนวณค่าความผิดพลาดสำหรับแบบจำลองที่เลือกขั้นสุดท้าย มีเทคนิคการตรวจ สอบความถูกต้องข้ามอื่นๆ เช่น
k-fold อย่างไรก็ตาม ฉันจะไม่อธิบายสิ่งเหล่านี้ในบทความนี้
เครื่องมือการเรียนรู้ของเครื่องและกรอบงาน Weka
เฟรมเวิร์กและไลบรารีส่วนใหญ่มีคอลเลกชั่นอัลกอริธึมการเรียนรู้ของเครื่องมากมาย นอกจากนี้ ยังมีอินเทอร์เฟซระดับสูงที่สะดวกสบายสำหรับการฝึกอบรม การทดสอบ และการประมวลผลโมเดลข้อมูล Weka เป็นหนึ่งในเฟรมเวิร์กยอดนิยมสำหรับ JVM Weka เป็นไลบรารี Java ที่ใช้งานได้จริงซึ่งมีการทดสอบแบบกราฟิกเพื่อตรวจสอบความถูกต้องของโมเดล ตัวอย่างด้านล่างใช้ไลบรารี Weka เพื่อสร้างชุดข้อมูลการฝึกอบรมที่มีคุณสมบัติและป้ายกำกับ วิธีการ
setClassIndex()
- สำหรับการทำเครื่องหมาย ใน Weka ป้ายกำกับถูกกำหนดให้เป็นคลาส:
ArrayList<ltAttribute> attributes = new ArrayList<>();
Attribute sizeAttribute = new Attribute("sizeFeature");
attributes.add(sizeAttribute);
Attribute squaredSizeAttribute = new Attribute("squaredSizeFeature");
attributes.add(squaredSizeAttribute);
Attribute priceAttribute = new Attribute("priceLabel");
attributes.add(priceAttribute);
Instances trainingDataset = new Instances("trainData", attributes, 5000);
trainingDataset.setClassIndex(trainingSet.numAttributes() - 1);
Instance instance = new DenseInstance(3);
instance.setValue(sizeAttribute, 90.0);
instance.setValue(squaredSizeAttribute, Math.pow(90.0, 2));
instance.setValue(priceAttribute, 249.0);
trainingDataset.add(instance);
Instance instance = new DenseInstance(3);
instance.setValue(sizeAttribute, 101.0);
...
ชุดข้อมูลและออบเจ็กต์ตัวอย่างสามารถบันทึกและโหลดจากไฟล์ได้ Weka ใช้
ARFF (รูปแบบไฟล์ความสัมพันธ์ของแอตทริบิวต์) ซึ่งได้รับการสนับสนุนโดยการวัดประสิทธิภาพกราฟิกของ Weka ชุดข้อมูลนี้ใช้เพื่อฝึกฟังก์ชันวัตถุประสงค์ที่เรียกว่าตัวแยกประเภทใน Weka ก่อนอื่น คุณต้องกำหนดฟังก์ชันวัตถุประสงค์ รหัสด้านล่าง
LinearRegression
จะสร้างอินสแตนซ์ของตัวแยกประเภท ตัวแยกประเภทนี้จะได้รับการฝึกอบรมโดยใช้
buildClassifier()
. วิธีการ
buildClassifier()
เลือกพารามิเตอร์ทีต้าตามข้อมูลการฝึกเพื่อค้นหาโมเดลเป้าหมายที่ดีที่สุด ด้วย Weka คุณไม่ต้องกังวลกับการตั้งค่าอัตราการเรียนรู้หรือจำนวนการวนซ้ำ Weka ยังดำเนินการปรับขนาดฟีเจอร์อย่างอิสระ
Classifier targetFunction = new LinearRegression();
targetFunction.buildClassifier(trainingDataset);
เมื่อทำการตั้งค่าเหล่านี้แล้ว ฟังก์ชันวัตถุประสงค์สามารถใช้เพื่อทำนายราคาบ้านได้ ดังที่แสดงด้านล่าง:
Instances unlabeledInstances = new Instances("predictionset", attributes, 1);
unlabeledInstances.setClassIndex(trainingSet.numAttributes() - 1);
Instance unlabeled = new DenseInstance(3);
unlabeled.setValue(sizeAttribute, 1330.0);
unlabeled.setValue(squaredSizeAttribute, Math.pow(1330.0, 2));
unlabeledInstances.add(unlabeled);
double prediction = targetFunction.classifyInstance(unlabeledInstances.get(0));
Weka จัดให้มีชั้นเรียน
Evaluation
เพื่อทดสอบตัวจําแนกหรือโมเดลที่ได้รับการฝึกอบรม ในโค้ดด้านล่าง มีการใช้อาร์เรย์ของข้อมูลการตรวจสอบที่เลือกไว้เพื่อหลีกเลี่ยงผลลัพธ์ที่ผิดพลาด ผลการวัด (ต้นทุนของข้อผิดพลาด) จะแสดงบนคอนโซล โดยทั่วไปแล้ว ผลการประเมินจะถูกนำมาใช้เพื่อเปรียบเทียบแบบจำลองที่ได้รับการฝึกฝนโดยใช้อัลกอริธึมการเรียนรู้ของเครื่องที่แตกต่างกัน หรือรูปแบบต่างๆ ของสิ่งเหล่านี้:
Evaluation evaluation = new Evaluation(trainingDataset);
evaluation.evaluateModel(targetFunction, validationDataset);
System.out.println(evaluation.toSummaryString("Results", false));
ตัวอย่างข้างต้นใช้การถดถอยเชิงเส้น ซึ่งจะทำนายค่าตัวเลข เช่น ราคาบ้าน โดยอิงตามค่าที่ป้อนเข้า การถดถอยเชิงเส้นรองรับการทำนายค่าตัวเลขต่อเนื่อง ในการทำนายค่าไบนารี (“ใช่” และ “ไม่ใช่”) คุณต้องใช้อัลกอริธึมการเรียนรู้ของเครื่องอื่น ตัวอย่างเช่น แผนผังการตัดสินใจ โครงข่ายประสาทเทียม หรือการถดถอยโลจิสติก
Classifier targetFunction = new Logistic();
targetFunction.buildClassifier(trainingSet);
คุณสามารถใช้อัลกอริธึมเหล่านี้เพื่อคาดการณ์ว่าข้อความอีเมลเป็นสแปม ทำนายสภาพอากาศ หรือคาดการณ์ว่าบ้านจะขายดีหรือไม่ หากคุณต้องการสอนอัลกอริธึมในการพยากรณ์อากาศหรือความเร็วของบ้านที่จะขาย คุณต้องมีชุดข้อมูลอื่น เช่น
topseller:
ArrayList<string> classVal = new ArrayList<>();
classVal.add("true");
classVal.add("false");
Attribute topsellerAttribute = new Attribute("topsellerLabel", classVal);
attributes.add(topsellerAttribute);
ชุดข้อมูลนี้จะใช้ในการฝึกตัวแยกประเภท
topseller
ใหม่ เมื่อได้รับการฝึกอบรมแล้ว การเรียกการคาดการณ์ควรส่งคืนดัชนีคลาสโทเค็นที่สามารถใช้เพื่อรับค่าที่คาดการณ์ไว้
int idx = (int) targetFunction.classifyInstance(unlabeledInstances.get(0));
String prediction = classVal.get(idx);
บทสรุป
แม้ว่าแมชชีนเลิร์นนิงจะมีความเกี่ยวข้องอย่างใกล้ชิดกับสถิติและใช้แนวคิดทางคณิตศาสตร์มากมาย แต่ชุดเครื่องมือแมชชีนเลิร์นนิงช่วยให้คุณเริ่มบูรณาการการเรียนรู้ของเครื่องเข้ากับโปรแกรมได้โดยไม่ต้องมีความรู้เชิงลึกเกี่ยวกับคณิตศาสตร์ อย่างไรก็ตาม ยิ่งคุณเข้าใจอัลกอริธึมการเรียนรู้ของเครื่องพื้นฐานได้ดียิ่งขึ้น เช่น อัลกอริธึมการถดถอยเชิงเส้นที่เราสำรวจในบทความนี้ คุณก็จะสามารถเลือกอัลกอริธึมที่เหมาะสมและปรับแต่งเพื่อให้ได้ประสิทธิภาพสูงสุดได้มากขึ้นเท่านั้น
แปลจากภาษาอังกฤษ ผู้แต่ง: Gregor Roth สถาปนิกซอฟต์แวร์ JavaWorld
GO TO FULL VERSION