Node.js에서 XGBoost를 사용하여 주택 가격 예측

Qu’est-ce que XGBoost ?

XGBoost est un algorithme d'apprentissage automatique populaire qui se classe régulièrement en bonne place dans Kaggle et dans d'autres concours de science des données. Ce qui distingue XGBoost, c'est sa capacité à combiner plusieurs modèles faibles (dans ce cas, des arbres de décision) en un modèle fort. Cela se fait grâce à une technique appelée gradient boosting, qui contribue à rendre l'algorithme robuste et très efficace pour une grande variété de tâches prédictives.

Comment fonctionne XGBoost ?

XGBoost utilise le gradient boosting, ce qui signifie qu'il construit des arbres de manière séquentielle où chaque arbre essaie de corriger les erreurs des arbres précédents. Voici une vue simplifiée du processus :

1. Faites une prédiction initiale (peut être la moyenne de toutes les valeurs cibles)
2. Calculez à quel point cette prédiction était fausse (l'erreur)
3. Construisez un arbre de décision pour prédire cette erreur
4. Ajoutez les prédictions de cet arbre à notre total de prédictions en cours (mais réduites pour éviter un excès de confiance)
5. Répétez les étapes 2 à 4 plusieurs fois

Par exemple, si nous prévoyons les prix de l'immobilier :

• Le premier arbre pourrait prédire 200 000 $
• Si le prix réel est de 250 000 $, l'erreur est de 50 000 $
• L'arbre suivant se concentre sur la prévision de cette erreur de 50 000 $
• La prédiction finale combine les prédictions de tous les arbres

Ce processus, combiné à des mathématiques et des optimisations intelligentes, rend XGBoost à la fois précis et rapide.

Pourquoi XGBoost dans Node.js ?

Bien que XGBoost soit à l'origine implémenté en tant que bibliothèque C, des liaisons sont disponibles pour des langages comme Python et R, ce qui le rend accessible à un large éventail de développeurs généralement spécialisés dans les données et l'apprentissage automatique.

J'ai récemment eu un projet qui avait des exigences strictes pour Node.js, j'ai donc vu une opportunité de combler le fossé en écrivant des liaisons pour Node.js. J'espère que cela contribuera à ouvrir la porte à davantage de ML pour les développeurs JavaScript.

Dans cet article, nous verrons de plus près comment utiliser XGBoost dans vos applications Node.js.

Conditions préalables

Avant de commencer, assurez-vous d'avoir :

• Système d'exploitation Linux (exigence actuelle pour xgboost_node)
• Node.js version 18.0.0 ou supérieure
• Compréhension de base des concepts d'apprentissage automatique

Installation

Installez les liaisons XGBoost Node.js à l'aide de npm :

npm install xgboost_node

Comprendre les données

Avant de passer au code, comprenons ce que représentent nos fonctionnalités dans l'exemple de prévision du prix de l'immobilier :

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

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

Voici ce que signifie chaque fonctionnalité :

• 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

위 내용은 Node.js에서 XGBoost를 사용하여 주택 가격 예측의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!