.NET, TensorFlow, dan kincir angin Kaggle - perjalanan dimulai

Ini adalah serangkaian artikel tentang perjalanan berkelanjutan saya ke hutan gelap kompetisi Kaggle sebagai pengembang .NET.

Saya akan fokus pada (hampir) jaringan saraf murni dalam artikel ini dan berikut. Ini berarti, bahwa sebagian besar bagian membosankan dari persiapan dataset, seperti mengisi nilai yang hilang, pemilihan fitur, analisis pencilan, dll. akan sengaja dilewati.

Tumpukan teknologi akan menjadi C # + TensorFlow tf.keras API. Mulai hari ini juga akan memerlukan Windows. Model yang lebih besar di artikel mendatang mungkin membutuhkan GPU yang sesuai agar waktu pelatihan mereka tetap waras.

Mari kita prediksi harga real estat!

House Prices adalah kompetisi yang bagus untuk pemula. Datasetnya kecil, tidak ada aturan khusus, papan publik memiliki banyak peserta, dan Anda dapat mengirimkan hingga 4 entri sehari.

Daftar di Kaggle, jika Anda belum melakukannya, bergabunglah dengan kompetisi ini, dan unduh datanya. Sasarannya adalah untuk memprediksi harga jual (kolom SalePrice) untuk entri dalam test.csv . Arsip berisi train.csv , yang memiliki sekitar 1500 entri dengan harga jual yang dikenal untuk pelatihan . Kami akan mulai dengan memuat dataset itu, dan menjelajahinya sedikit, sebelum masuk ke jaringan saraf.

Analisis data pelatihan

Apakah saya mengatakan kami akan melewatkan persiapan dataset? Saya berbohong! Anda harus melihatnya setidaknya sekali.

Yang mengejutkan saya, saya tidak menemukan cara mudah untuk memuat file .csv di perpustakaan kelas standar .NET, jadi saya menginstal paket NuGet, yang disebut CsvHelper . Untuk mempermudah manipulasi data, saya juga mendapatkan paket ekstensi LINQ favorit saya, MoreLinq .




Data terlihat seperti ini (hanya beberapa baris dan kolom):

Id	MSSubClass	Menandai	LotFrontage	Lotarea
1	60	RL	65	8450
2	20	RL	80	9600
3	60	RL	68	11250
4	70	RL	60	9550

Setelah memuat data, kami perlu menghapus kolom Id , karena sebenarnya tidak terkait dengan harga rumah:

 var trainData = LoadData("train.csv"); trainData.Columns.Remove("Id"); 

Menganalisis tipe data kolom

DataTable tidak secara otomatis menyimpulkan tipe data kolom, dan menganggap itu semua string. Jadi langkah selanjutnya adalah menentukan apa yang sebenarnya kita miliki. Untuk setiap kolom saya menghitung statistik berikut: jumlah nilai yang berbeda, berapa banyak dari mereka adalah bilangan bulat, dan berapa banyak dari mereka adalah angka floating point (kode sumber dengan semua metode pembantu akan dihubungkan pada akhir artikel):

 var values = rows.Select(row => (string)row[column]); double floats = values.Percentage(v => double.TryParse(v, out _)); double ints = values.Percentage(v => int.TryParse(v, out _)); int distincts = values.Distinct().Count(); 

Kolom angka

Ternyata sebagian besar kolom sebenarnya int, tetapi karena sebagian besar jaringan saraf bekerja pada angka mengambang, kita akan mengubahnya menjadi ganda.

Kolom kategorikal

Kolom lain menggambarkan kategori milik properti yang dijual. Tidak ada satu pun dari mereka yang memiliki terlalu banyak nilai berbeda, yang bagus. Untuk menggunakannya sebagai input untuk jaringan saraf kita di masa depan, mereka harus dikonversi menjadi dua kali lipat juga.

Awalnya, saya hanya menetapkan angka dari 0 ke differValueCount - 1 untuk mereka, tetapi itu tidak masuk akal, karena sebenarnya tidak ada perkembangan dari "Facade: Blue" melalui "Facade: Green" menjadi "Facade: White". Jadi sejak awal saya mengubahnya menjadi apa yang disebut pengkodean satu-panas , di mana setiap nilai unik mendapat kolom input yang terpisah. Misalnya "Fasad: Biru" menjadi [1,0,0], dan "Fasad: Putih" menjadi [0,0,1].

Menyatukan mereka semua

Dengan mengingat hal itu, saya membuat ValueNormalizer berikut, yang mengambil beberapa info tentang nilai-nilai di dalam kolom, dan mengembalikan fungsi, yang mengubah nilai ( string ) menjadi vektor fitur numerik untuk jaringan saraf ( double [] ):


Sekarang kita punya data yang dikonversi menjadi format, cocok untuk jaringan saraf. Sudah waktunya untuk membangun satu.

Membangun jaringan saraf

Mulai hari ini, Anda harus menggunakan mesin Windows untuk itu.

Jika Anda sudah menginstal Python dan TensorFlow 1.1x, yang Anda butuhkan adalah

 <PackageReference Include="Gradient" Version="0.1.10-tech-preview3" /> 

dalam file .csproj modern Anda. Jika tidak, lihat manual Gradient untuk melakukan pengaturan awal.

Setelah paket aktif dan berjalan, kita dapat membuat jaringan mendalam pertama kami.

 using tensorflow; using tensorflow.keras; using tensorflow.keras.layers; using tensorflow.train; ... var model = new Sequential(new Layer[] { new Dense(units: 16, activation: tf.nn.relu_fn), new Dropout(rate: 0.1), new Dense(units: 10, activation: tf.nn.relu_fn), new Dense(units: 1, activation: tf.nn.relu_fn), }); model.compile(optimizer: new AdamOptimizer(), loss: "mean_squared_error"); 

Ini akan membuat jaringan saraf yang tidak terlatih dengan 3 lapisan neuron, dan lapisan putus, yang membantu mencegah overfitting.

Beri makan data

TensorFlow mengharapkan datanya baik dalam array NumPy, atau tensor yang ada. Saya mengubah DataRows menjadi array NumPy:

 using numpy; ... const string predict = "SalePrice"; ndarray GetInputs(IEnumerable<DataRow> rowSeq) { return np.array(rowSeq.Select(row => np.array( columnTypes .Where(c => c.column.ColumnName != predict) .SelectMany(column => column.normalizer( row.Table.Columns.Contains(column.column.ColumnName) ? (string)row[column.column.ColumnName] : "-1")) .ToArray())) .ToArray() ); } var predictColumn = columnTypes.Single(c => c.column.ColumnName == predict); ndarray trainOutputs = np.array(predictColumn.trainValues .AsDouble() .Select(v => v ?? -1) .ToArray()); ndarray trainInputs = GetInputs(trainRows); 

Dalam kode di atas kami mengkonversi setiap DataRow menjadi ndarray dengan mengambil setiap sel di dalamnya, dan menerapkan ValueNormalizer yang sesuai dengan kolomnya. Lalu kita meletakkan semua baris ke ndarray lain, mendapatkan array array.

Tidak diperlukan transformasi seperti itu untuk keluaran, tempat kami hanya mengonversi nilai kereta ke ndarray lain.

Saatnya turun gradien

Dengan pengaturan ini, yang perlu kita lakukan untuk melatih jaringan kita adalah memanggil fungsi fit model:

 model.fit(trainInputs, trainOutputs, epochs: 2000, validation_split: 0.075, verbose: 2); 

Panggilan ini sebenarnya akan menyisihkan 7,5% terakhir dari pelatihan yang ditetapkan untuk validasi, kemudian ulangi sebanyak 2000 kali berikut ini:

1. membagi sisa trainInput menjadi batch
2. memberi makan batch ini satu per satu ke dalam jaringan saraf
3. hitung kesalahan menggunakan fungsi kerugian yang kami definisikan di atas
4. backpropagate kesalahan melalui gradien koneksi neuron individu, menyesuaikan bobot

Saat pelatihan, itu akan menampilkan kesalahan jaringan pada data yang disisihkan untuk validasi sebagai val_loss dan kesalahan pada data pelatihan itu sendiri sebagai kerugian saja. Secara umum, jika val_loss menjadi lebih besar, daripada kerugian , itu berarti jaringan mulai overfitting. Saya akan membahasnya secara lebih rinci dalam artikel-artikel berikut.

Jika Anda melakukan semuanya dengan benar, akar kuadrat dari salah satu kerugian Anda harus berada di urutan 20000.

Kiriman

Saya tidak akan bicara banyak tentang menghasilkan file untuk dikirim di sini. Kode untuk menghitung output sederhana:

 const string SubmissionInputFile = "test.csv"; DataTable submissionData = LoadData(SubmissionInputFile); var submissionRows = submissionData.Rows.Cast<DataRow>(); ndarray submissionInputs = GetInputs(submissionRows); ndarray sumissionOutputs = model.predict(submissionInputs); 

yang sebagian besar menggunakan fungsi, yang didefinisikan sebelumnya.

Maka Anda perlu menuliskannya ke file .csv, yang hanya merupakan daftar pasangan Id, predict_value.

Ketika Anda mengirimkan hasil Anda, Anda harus mendapatkan skor pada urutan 0,17, yang akan berada di suatu tempat di kuartal terakhir tabel papan publik. Tapi hei, jika sesederhana jaringan 3 layer dengan 27 neuron, para ilmuwan data sial itu tidak akan mendapatkan $ 300k + / y total kompensasi dari perusahaan-perusahaan besar AS

Membungkus

Kode sumber lengkap untuk entri ini (dengan semua pembantu, dan beberapa bagian komentar dari eksplorasi dan eksperimen saya sebelumnya) adalah sekitar 200 baris di PasteBin .

Pada artikel berikutnya Anda akan melihat orang-orang jahat saya mencoba masuk ke dalam 50% teratas dari papan peringkat publik. Ini akan menjadi petualangan seorang penjelajah amatir, pertarungan dengan The Windmill of Overfitting dengan satu-satunya alat yang dimiliki pengembara - model yang lebih besar (mis. NN dalam, ingat, tidak ada rekayasa fitur manual!). Ini akan menjadi kurang dari tutorial pengkodean, dan lebih dari pencarian pikiran dengan matematika yang benar-benar jahat dan kesimpulan yang aneh. Tetap disini!

Tautan

Kaggle
Persaingan Harga Rumah di Kaggle
Tutorial regresi TensorFlow
Halaman muka TensorFlow
Referensi TensorFlow API
Gradient (TensorFlow binding)