Prédire les prix des maisons avec XGBoost dans Node.js

Was ist XGBoost?

XGBoost ist ein beliebter Algorithmus für maschinelles Lernen, der bei Kaggle und anderen Data-Science-Wettbewerben regelmäßig Spitzenplätze belegt. Was XGBoost auszeichnet, ist seine Fähigkeit, mehrere schwache Modelle (in diesem Fall Entscheidungsbäume) zu einem starken zu kombinieren. Dies geschieht durch eine Technik namens Gradient Boosting, die dazu beiträgt, den Algorithmus robust und hochwirksam für eine Vielzahl von Vorhersageaufgaben zu machen.

Wie funktioniert XGBoost?

XGBoost verwendet Gradient Boosting, was bedeutet, dass Bäume nacheinander erstellt werden, wobei jeder Baum versucht, die Fehler der vorherigen Bäume zu korrigieren. Hier ist eine vereinfachte Ansicht des Prozesses:

1. Machen Sie eine erste Vorhersage (könnte der Durchschnitt aller Zielwerte sein)
2. Berechnen Sie, wie falsch diese Vorhersage war (der Fehler)
3. Erstellen Sie einen Entscheidungsbaum, um diesen Fehler vorherzusagen
4. Fügen Sie die Vorhersagen dieses Baums zu unserer laufenden Vorhersagesumme hinzu (aber verkleinern Sie sie, um übermäßiges Vertrauen zu vermeiden)
5. Wiederholen Sie die Schritte 2–4 viele Male

Zum Beispiel, wenn wir Immobilienpreise vorhersagen:

• Der erste Baum könnte 200.000 US-Dollar vorhersagen
• Wenn der tatsächliche Preis 250.000 $ beträgt, beträgt der Fehler 50.000 $
• Der nächste Baum konzentriert sich auf die Vorhersage dieses 50.000-Dollar-Fehlers
• Die endgültige Vorhersage kombiniert die Vorhersagen aller Bäume

Dieser Prozess, kombiniert mit cleverer Mathematik und Optimierungen, macht XGBoost sowohl präzise als auch schnell.

Warum XGBoost in Node.js?

Während XGBoost ursprünglich als C-Bibliothek implementiert ist, stehen Bindungen für Sprachen wie Python und R zur Verfügung, wodurch es für eine breite Palette von Entwicklern zugänglich ist, die sich typischerweise auf Daten und maschinelles Lernen spezialisieren.

Ich hatte kürzlich ein Projekt, das eine starke Anforderung für Node.js hatte, also sah ich eine Möglichkeit, diese Lücke zu schließen, indem ich Bindungen für Node.js schrieb. Ich hoffe, dass dies dazu beiträgt, JavaScript-Entwicklern die Tür zu mehr ML zu öffnen.

In diesem Artikel werfen wir einen genaueren Blick auf die Verwendung von XGBoost in Ihren Node.js-Anwendungen.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes haben:

• Linux-Betriebssystem (aktuelle Anforderung für xgboost_node)
• Node.js Version 18.0.0 oder höher
• Grundlegendes Verständnis der Konzepte des maschinellen Lernens

Installation

Installieren Sie die XGBoost Node.js-Bindungen mit npm:

npm install xgboost_node

Die Daten verstehen

Bevor wir uns mit dem Code befassen, wollen wir verstehen, was unsere Funktionen im Beispiel für die Hauspreisvorhersage darstellen:

// Each feature array represents:
[square_feet, property_age, total_rooms, has_parking, neighborhood_type, is_furnished]

// Example:
[1200,       8,            10,           0,           1,                1        ]

Hier ist, was jede Funktion bedeutet:

• square_feet: The size of the property (e.g., 1200 sq ft)
• property_age: Age of the property in years (e.g., 8 years)
• total_rooms: Total number of rooms (e.g., 10 rooms)
• has_parking: Binary (0 = no parking, 1 = has parking)
• neighborhood_type: Category (1 = residential, 2 = commercial area)
• is_furnished: Binary (0 = unfurnished, 1 = furnished)

And the corresponding labels array contains house prices in thousands (e.g., 250 means $250,000).

Transforming Your Data

If you have raw data in a different format, here's how to transform it for XGBoost:

// Let's say you have data in this format:
const rawHouses = [
    {
        address: "123 Main St",
        sqft: 1200,
        yearBuilt: 2015,
        rooms: 10,
        parking: "Yes",
        neighborhood: "Residential",
        furnished: true,
        price: 250000
    },
    // ... more houses
];

// Transform it to XGBoost format:
const features = rawHouses.map(house => [
    house.sqft,
    new Date().getFullYear() - house.yearBuilt,  // Convert year built to age
    house.rooms,
    house.parking === "Yes" ? 1 : 0,             // Convert Yes/No to 1/0
    house.neighborhood === "Residential" ? 1 : 2, // Convert category to number
    house.furnished ? 1 : 0                       // Convert boolean to 1/0
]);

const labels = rawHouses.map(house => house.price / 1000); // Convert price to thousands

Training Your First Model

Here's a complete example that shows how to train a model and make predictions:

import xgboost from 'xgboost_node';

async function test() {
    const features = [
        [1200, 8, 10, 0, 1, 1],
        [800, 14, 15, 1, 2, 0],
        [1200, 8, 10, 0, 1, 1],
        [1200, 8, 10, 0, 1, 1],
        [1200, 8, 10, 0, 1, 1],
        [800, 14, 15, 1, 2, 0],
        [1200, 8, 10, 0, 1, 1],
        [1200, 8, 10, 0, 1, 1],
    ];
    const labels = [250, 180, 250, 180, 250, 180, 250, 180];

    const params = {
        max_depth: 3,
        eta: 0.3,
        objective: 'reg:squarederror',
        eval_metric: 'rmse',
        nthread: 4,
        num_round: 100,
        min_child_weight: 1,
        subsample: 0.8,
        colsample_bytree: 0.8,
    };

    try {
        await xgboost.train(features, labels, params);
        const predictions = await xgboost.predict([[1000, 0, 1, 0, 1, 1], [800, 0, 1, 0, 1, 1]]);
        console.log('Predicted value:', predictions[0]);
    } catch (error) {
        console.error('Error:', error);
    }
}

test();

The example above shows how to:

1. Set up training data with features and labels
2. Configure XGBoost parameters for training
3. Train the model
4. Make predictions on new data

Model Management

XGBoost provides straightforward methods for saving and loading models:

// Save model after training
await xgboost.saveModel('model.xgb');

// Load model for predictions
await xgboost.loadModel('model.xgb');

Further Considerations

You may have noticed there are parameters for this model. I would advise looking into XGBoost documentation to understand how to tune and choose your parameters. Here's what some of these parameters are trying to achieve:

const params = {
    max_depth: 3,              // Controls how deep each tree can grow
    eta: 0.3,                 // Learning rate - how much we adjust for each tree
    objective: 'reg:squarederror',  // For regression problems
    eval_metric: 'rmse',      // How we measure prediction errors
    nthread: 4,               // Number of parallel processing threads
    num_round: 100,           // Number of trees to build
    min_child_weight: 1,      // Minimum amount of data in a leaf
    subsample: 0.8,           // Fraction of data to use in each tree
    colsample_bytree: 0.8,    // Fraction of features to consider for each tree
};

These parameters significantly impact your model's performance and behavior. For example:

• Lower max_depth helps prevent overfitting but might underfit if too low
• Lower eta means slower learning but can lead to better generalization
• Higher num_round means more trees, which can improve accuracy but increases training time

Conclusion

This guide provides a starting point for using XGBoost in Node.js. For production use, I recommend:

1. Understanding and tuning the XGBoost parameters for your specific use case
2. Implementing proper cross-validation to evaluate your model
3. Testing with different data scenarios to ensure robustness
4. Monitoring model performance in production

---

Jonathan Farrow

@farrow_jonny

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!