Meramalkan Harga Rumah dengan XGBoost dalam Node.js

Apakah XGBoost?

XGBoost ialah algoritma pembelajaran mesin popular yang kerap meletakkan kedudukan tinggi dalam pertandingan sains data Kaggle dan lain-lain. Apa yang membezakan XGBoost ialah keupayaannya untuk menggabungkan berbilang model lemah (dalam kes ini, pepohon keputusan) menjadi model yang kuat. Ini dilakukan melalui teknik yang dipanggil peningkatan kecerunan, yang membantu menjadikan algoritma teguh dan sangat berkesan untuk pelbagai jenis tugas ramalan.

Bagaimanakah XGBoost Berfungsi?

XGBoost menggunakan peningkatan kecerunan, yang bermaksud ia membina pokok secara berurutan di mana setiap pokok cuba membetulkan kesilapan pokok sebelumnya. Berikut ialah paparan ringkas proses:

1. Buat ramalan awal (boleh jadi purata semua nilai sasaran)
2. Kira betapa salahnya ramalan ini (ralat)
3. Bina pepohon keputusan untuk meramalkan ralat ini
4. Tambahkan ramalan pokok ini pada jumlah ramalan larian kami (tetapi kecilkan untuk mengelakkan terlalu yakin)
5. Ulang langkah 2-4 banyak kali

Contohnya, jika kita meramalkan harga rumah:

• Pokok pertama mungkin meramalkan $200,000
• Jika harga sebenar ialah $250,000, ralatnya ialah $50,000
• Pokok seterusnya memfokuskan pada meramalkan ralat $50,000 ini
• Ramalan akhir menggabungkan ramalan semua pokok

Proses ini, digabungkan dengan beberapa matematik pintar dan pengoptimuman, menjadikan XGBoost tepat dan pantas.

Mengapa XGBoost dalam Node.js?

Walaupun XGBoost pada asalnya dilaksanakan sebagai perpustakaan C, terdapat pengikatan yang tersedia untuk bahasa seperti Python dan R, menjadikannya boleh diakses oleh pelbagai pembangun yang biasanya pakar dalam data dan pembelajaran mesin.

Baru-baru ini saya mempunyai projek yang mempunyai keperluan yang sukar untuk Node.js, jadi saya melihat peluang untuk merapatkan jurang dengan menulis binding untuk Node.js. Saya harap ini membantu membuka pintu kepada lebih banyak ML untuk pembangun JavaScript.

Dalam artikel ini, kami akan melihat dengan lebih dekat cara menggunakan XGBoost dalam aplikasi Node.js anda.

Prasyarat

Sebelum bermula, pastikan anda mempunyai:

• Sistem pengendalian Linux (keperluan semasa untuk xgboost_node)
• Node.js versi 18.0.0 atau lebih tinggi
• Pemahaman asas konsep pembelajaran mesin

Pemasangan

Pasang pengikatan XGBoost Node.js menggunakan npm:

npm install xgboost_node

Memahami Data

Sebelum memasuki kod, mari kita fahami ciri-ciri kami dalam contoh ramalan harga rumah:

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

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

Berikut ialah maksud setiap ciri:

• 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

Atas ialah kandungan terperinci Meramalkan Harga Rumah dengan XGBoost dalam Node.js. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!