Pembelajaran Mesin untuk Jurutera Perisian

Beri tahu saya jika anda mendapati ini berharga dan saya akan teruskan!

Bab 1 - Model linear

Salah satu konsep yang paling ringkas lagi berkuasa ialah model linear.

Dalam ML, salah satu matlamat utama kami adalah untuk membuat ramalan berdasarkan data. Model linear adalah seperti "Hello World" pembelajaran mesin - ia mudah tetapi membentuk asas untuk memahami model yang lebih kompleks.

Jom bina model untuk meramal harga rumah. Dalam contoh ini, output ialah "harga rumah" yang dijangkakan dan input anda adalah seperti "sqft", "num_bedrooms", dll...

def prediction(sqft, num_bedrooms, num_baths):
    weight_1, weight_2, weight_3 = .0, .0, .0  
    home_price = weight_1*sqft, weight_2*num_bedrooms, weight_3*num_baths
    return home_price

Anda akan melihat "berat" untuk setiap input. Berat inilah yang mencipta keajaiban di sebalik ramalan. Contoh ini membosankan kerana ia akan sentiasa mengeluarkan sifar kerana pemberat adalah sifar.

Jadi mari kita temui bagaimana kita boleh mencari pemberat ini.

Mencari berat

Proses untuk mencari pemberat dipanggil "melatih" model.

• Pertama, kami memerlukan set data rumah dengan ciri (input) dan harga (output) yang diketahui. Contohnya:

data = [
    {"sqft": 1000, "bedrooms": 2, "baths": 1, "price": 200000},
    {"sqft": 1500, "bedrooms": 3, "baths": 2, "price": 300000},
    # ... more data points ...
]

• Sebelum kami mencipta cara untuk mengemas kini berat kami, kami perlu mengetahui sejauh mana ramalan kami. Kita boleh mengira perbezaan antara ramalan kita dan nilai sebenar.

home_price = prediction(1000, 2, 1) # our weights are currently zero, so this is zero
actual_value = 200000

error = home_price - actual_value # 0 - 200000 we are way off. 
# let's square this value so we aren't dealing with negatives
error = home_price**2

Sekarang kami mempunyai cara untuk mengetahui sejauh mana (ralat) kami untuk satu titik data, kami boleh mengira ralat purata merentas semua titik data. Ini biasanya dirujuk sebagai ralat kuasa dua min.

• Akhir sekali, kemas kini pemberat dengan cara yang mengurangkan min ralat kuasa dua.

Kita boleh, sudah tentu, memilih nombor rawak dan terus menyimpan nilai terbaik semasa kita pergi- tetapi itu tidak cekap. Jadi mari kita teroka kaedah yang berbeza: keturunan kecerunan.

Keturunan Kecerunan

Keturunan kecerunan ialah algoritma pengoptimuman yang digunakan untuk mencari pemberat terbaik untuk model kami.

Kecerunan ialah vektor yang memberitahu kita cara ralat berubah semasa kita membuat perubahan kecil pada setiap berat.

Gerak hati bar sisi
Bayangkan berdiri di atas landskap berbukit, dan matlamat anda adalah untuk mencapai titik terendah (ralat minimum). Kecerunan adalah seperti kompas yang sentiasa menunjukkan kepada pendakian yang paling curam. Dengan melawan arah kecerunan, kami mengorak langkah ke arah titik terendah.

Begini cara ia berfungsi:

1. Mulakan dengan pemberat rawak (atau sifar).
2. Kira ralat untuk pemberat semasa.
3. Kira kecerunan (cerun) ralat untuk setiap berat.
4. Kemas kini pemberat dengan menggerakkan langkah kecil ke arah yang mengurangkan ralat.
5. Ulang langkah 2-4 sehingga ralat berhenti berkurangan dengan ketara.

Bagaimanakah kita mengira kecerunan untuk setiap ralat?

Salah satu cara untuk mengira kecerunan adalah dengan membuat perubahan kecil dalam berat, lihat bagaimana ia memberi kesan kepada ralat kami dan lihat ke mana kami harus bergerak dari situ.

def calculate_gradient(weight, data, feature_index, step_size=1e-5):
    original_error = calculate_mean_squared_error(weight, data)

    # Slightly increase the weight
    weight[feature_index] += step_size
    new_error = calculate_mean_squared_error(weight, data)

    # Calculate the slope
    gradient = (new_error - original_error) / step_size

    # Reset the weight
    weight[feature_index] -= step_size

    return gradient

Pecahan Langkah demi Langkah

• Parameter Input:

  • berat: Set pemberat semasa untuk model kami.
  • data: Set data ciri dan harga rumah kami.
  • feature_index: Berat yang kami kira kecerunan untuk (0 untuk kaki persegi, 1 untuk bilik tidur, 2 untuk bilik mandi).
  • step_size: Nilai kecil yang kami gunakan untuk mengubah sedikit berat (lalai ialah 1e-5 atau 0.00001).

• Kira Ralat Asal:
  
  

   original_error = calculate_mean_squared_error(weight, data)

Kami mula-mula mengira ralat min kuasa dua dengan pemberat semasa kami. Ini memberi kita titik permulaan.

• Tingkatkan Sedikit Berat Badan:

   weight[feature_index] += step_size

Kami menambah berat dengan jumlah yang kecil (step_size). Ini membolehkan kami melihat bagaimana perubahan kecil dalam berat mempengaruhi kesilapan kami.

• Kira Ralat Baharu:

   new_error = calculate_mean_squared_error(weight, data)

Kami mengira ralat kuasa dua min sekali lagi dengan berat meningkat sedikit.

• Kira Cerun (Kecerunan):

   gradient = (new_error - original_error) / step_size

Ini adalah langkah utama. Kami bertanya: "Berapa banyak ralat berubah apabila kami meningkatkan sedikit berat?"

• Jika new_error > ralat_asli, kecerunan adalah positif, bermakna peningkatan berat ini meningkatkan ralat.
• Jika new_error < original_error, kecerunan adalah negatif, bermakna peningkatan berat ini mengurangkan ralat.

• Magnitud memberitahu kita betapa sensitifnya ralat terhadap perubahan berat ini.

  • Tetapkan Semula Berat:

   weight[feature_index] -= step_size

Kami meletakkan berat semula kepada nilai asalnya kerana kami menguji perkara yang akan berlaku jika kami menukarnya.

• Kembalikan Gradien:

   return gradient

Kami mengembalikan kecerunan yang dikira untuk berat ini.

This is called "numerical gradient calculation" or "finite difference method". We're approximating the gradient instead of calculating it analytically.

Let's update the weights

Now that we have our gradients, we can push our weights in the opposite direction of the gradient by subtracting the gradient.

weights[i] -= gradients[i]

If our gradient is too large, we could easily overshoot our minimum by updating our weight too much. To fix this, we can multiply the gradient by some small number:

learning_rate = 0.00001
weights[i] -= learning_rate*gradients[i]

And so here is how we do it for all of the weights:

def gradient_descent(data, learning_rate=0.00001, num_iterations=1000):
    weights = [0, 0, 0]  # Start with zero weights

    for _ in range(num_iterations):
        gradients = [
            calculate_gradient(weights, data, 0), # sqft
            calculate_gradient(weights, data, 1), # bedrooms
            calculate_gradient(weights, data, 2)  # bathrooms
        ]

        # Update each weight
        for i in range(3):
            weights[i] -= learning_rate * gradients[i]

        if _ % 100 == 0:
            error = calculate_mean_squared_error(weights, data)
            print(f"Iteration {_}, Error: {error}, Weights: {weights}")

    return weights

Finally, we have our weights!

Interpreting the Model

Once we have our trained weights, we can use them to interpret our model:

• The weight for 'sqft' represents the price increase per square foot.
• The weight for 'bedrooms' represents the price increase per additional bedroom.
• The weight for 'baths' represents the price increase per additional bathroom.

For example, if our trained weights are [100, 10000, 15000], it means:

• Each square foot adds $100 to the home price.
• Each bedroom adds $10,000 to the home price.
• Each bathroom adds $15,000 to the home price.

Linear models, despite their simplicity, are powerful tools in machine learning. They provide a foundation for understanding more complex algorithms and offer interpretable insights into real-world problems.

Atas ialah kandungan terperinci Pembelajaran Mesin untuk Jurutera Perisian. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!