การเรียนรู้ของเครื่องสำหรับนักพัฒนา Java ตอนที่ 2

การเรียนรู้ของเครื่องสำหรับนักพัฒนา 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);
 // предсказываем meaning и вычисляем ошибку базируясь на реальном
 //значении (метка)
 double predicted = targetFunction.apply(featureVector);
 double label = labels.get(i);
 double gap = predicted - label;
 sumSquaredErrors += Math.pow(gap, 2);
 }

 // Вычисляем и возращаем meaning ошибки (чем меньше тем лучше)
 return (1.0 / (2 * m)) * sumSquaredErrors;
}

การเรียนรู้ฟังก์ชั่นเป้าหมาย

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

การไล่ระดับโคตร

การไล่ระดับสีจะช่วยลดฟังก์ชันต้นทุนให้เหลือน้อยที่สุด ซึ่งหมายความว่าจะใช้เพื่อค้นหาพารามิเตอร์ทีต้าที่มีต้นทุนขั้นต่ำ(J(θ))ตามข้อมูลการฝึกอบรม ต่อไปนี้เป็นอัลกอริทึมแบบง่ายสำหรับการคำนวณค่าทีต้าใหม่ที่เหมาะสมยิ่งขึ้น: ดังนั้น พารามิเตอร์ของเวกเตอร์ทีต้าจะดีขึ้นเมื่อมีการวนซ้ำอัลกอริทึมแต่ละครั้ง ค่าสัมประสิทธิ์การเรียนรู้ α ระบุจำนวนการคำนวณในการวนซ้ำแต่ละครั้ง การคำนวณเหล่านี้สามารถดำเนินการได้จนกว่าจะพบค่าทีต้า "ดี" ตัวอย่างเช่น ฟังก์ชันการถดถอยเชิงเส้นด้านล่างมีพารามิเตอร์ทีต้าสามตัว: ในการวนซ้ำแต่ละครั้ง ค่าใหม่จะถูกคำนวณสำหรับพารามิเตอร์ทีต้าแต่ละตัว: , และ หลังจากการวนซ้ำแต่ละครั้ง คุณสามารถสร้างการใช้งานใหม่ที่เหมาะสมยิ่งขึ้นได้โดยใช้เวกเตอร์ทีต้าใหม่{ θ ₀ , θ ₁ , θ ₂ } รายการ-4แสดงโค้ด Java สำหรับอัลกอริธึมการสลายการไล่ระดับสี ทีต้าสำหรับฟังก์ชันการถดถอยจะได้รับการฝึกโดยใช้ข้อมูลการฝึก ข้อมูลเครื่องหมาย อัตราการเรียนรู้ ผลลัพธ์จะเป็นฟังก์ชันวัตถุประสงค์ที่ได้รับการปรับปรุงโดยใช้พารามิเตอร์ทีต้า วิธีการนี้จะถูกเรียกครั้งแล้วครั้งเล่า โดยผ่านฟังก์ชันวัตถุประสงค์ใหม่และพารามิเตอร์ทีต้าใหม่จากการคำนวณครั้งก่อน และการเรียกเหล่านี้จะถูกทำซ้ำจนกว่าฟังก์ชันวัตถุประสงค์ที่กำหนดค่าไว้จะถึงจุดต่ำสุด: θ0θ1θ2LinearRegressionFunction(α)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];

 // вычисление нового значения тета для каждого element тета массива
 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): การใช้คุณลักษณะหลายรายการจำเป็นต้องมีการปรับขนาดคุณลักษณะซึ่งใช้เพื่อกำหนดช่วงของคุณลักษณะต่างๆ ให้เป็นมาตรฐาน ดังนั้นช่วงของค่าสำหรับ แอตทริบิวต์ ขนาด²จึงมากกว่าช่วงของค่าสำหรับแอตทริบิวต์ขนาดอย่างมาก หากไม่มีการปรับขนาดคุณลักษณะขนาด²จะส่งผลต่อฟังก์ชันต้นทุนอย่างไม่เหมาะสม ข้อผิดพลาดที่เกิดจาก แอตทริบิวต์ ขนาด²จะมากกว่าข้อผิดพลาดที่เกิดจากแอตทริบิวต์ขนาดอย่างมาก อัลกอริธึมการปรับขนาดคุณสมบัติอย่างง่ายมีดังต่อไปนี้: อัลกอริทึมนี้ถูกนำไปใช้ในคลาสFeaturesScalingในโค้ดตัวอย่างด้านล่าง ชั้นเรียนFeaturesScalingนำเสนอวิธีการเชิงพาณิชย์สำหรับการสร้างฟังก์ชันการปรับขนาดที่ปรับให้เข้ากับข้อมูลการฝึก ภายใน อินสแตนซ์ข้อมูลการฝึกอบรมจะใช้ในการคำนวณค่าเฉลี่ย ค่าต่ำสุด และค่าสูงสุด ฟังก์ชันผลลัพธ์จะใช้เวกเตอร์คุณลักษณะและสร้างเวกเตอร์ใหม่ที่มีคุณสมบัติปรับขนาด การปรับขนาดคุณสมบัติเป็นสิ่งจำเป็นสำหรับทั้งกระบวนการเรียนรู้และกระบวนการทำนาย ดังที่แสดงด้านล่าง:

// создание массива данных
List<ltDouble[]> dataset = new ArrayList<>();
dataset.add(new Double[] { 1.0, 90.0, 8100.0 }); // feature vector of house#1
dataset.add(new Double[] { 1.0, 101.0, 10201.0 }); // feature vector of house#2
dataset.add(new Double[] { 1.0, 103.0, 10609.0 }); // ...
//...

// создание меток
List<ltDouble> labels = new ArrayList<>();
labels.add(249.0); // price label of house#1
labels.add(338.0); // price label of house#2
labels.add(304.0); // ...
//...

// создание расширенного списка признаков
Function<ltDouble[], Double[]> scalingFunc = FeaturesScaling.createFunction(dataset);
List<ltDouble[]> scaledDataset = dataset.stream().map(scalingFunc).collect(Collectors.toList());

// создаем функцию которая инициализирует теты и осуществляет обучение //используя коэффициент обучения 0.1

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);
}

// делаем предсказание стоимости дома с площадью 600 m2
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);


// создаем и заполняем список признаков 5000 примеров
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:

// использование атрибута маркера topseller instead of атрибута маркера цена
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