Sebuah Pengantar Ekonometrika struktural Julia

Tutorial ini diadaptasi dari Julia pembelajaran dalam pengantar kedua saya siklus praktek Komputer Economist , Departemen Ekonomi, Universitas Chicago.

Tutorial adalah 5 bagian:

  1. Instalasi Julia + Juno IDE, serta paket alat
  2. Definisi tantangan ekonomi structural
  3. generasi, manajemen dan visualisasi regresi
  4. simulasi numerik dari perilaku pembatasan agen optimal
  5. metode diparalelkan kali evaluasi simulasi

Berikut Github repository untuk meniru hasil dalam tutorial ini.



Instalasi 1. Julia + Juno IDE dan paket berguna

Mungkin kendala terbesar untuk penggunaan Julia di masa lalu telah kurangnya mudah -untuk menginstal IDE. Itu sekali bernama Julia Studio IDE yang mudah digunakan sebagai populer rstudio A. Pada saat itu, Anda dapat menginstal dan menjalankan Julia Julia Studio + 5 menit dibandingkan dengan jam itu dapat mengambil untuk menginstal Python dan kemasannya dasar dan IDE. Ketika ia menerbitkan versi 0.3.X dari Julia, Julia studio tidak bekerja, dan Notebook direkomendasikan IJulia, yang membutuhkan instalasi Python dan IPython hanya menggunakan Julia, jadi tidak ada argumen bahwa Julia lebih mudah untuk menginstal Python hilang.

Sekarang, dengan versi 0.4.x dari Julia, Juno telah memberikan IDE yang sangat baik yang datang pra-dibundel dengan Julia untuk kenyamanan, dan Anda dapat menginstal Julia + Juno FDI dalam 5 menit. Berikut adalah beberapa panduan untuk membantu Anda melalui proses instalasi:

  1. Buka http://julialang.org/downloads/ dan mencari “ Julia balok + Juno IDE “. Klik untuk men-download paket ke sistem anda (Windows, Mac atau Linux).
  2. Setelah download pendek (tentang bahasa Julia + Juno IDE kurang dari 1GB), buka file tersebut dan klik petunjuk instalasi.
  3. Buka Juno dan mencoba untuk menjalankan garis yang sangat sederhana dari kode. Sebagai contoh, ketik 2 + 2 , pilih teks, klik kanan dan pilih Catatan: . Gelembung harus menunjukkan 4 di sebelah baris kode.
    • Shooting Masalah: Pada Mac saya menjalankan OS X Mavericks, 2 + 2 gagal dan tidak perlu error itu diproduksi. Setelah beberapa penelitian, saya menemukan bahwa solusinya adalah menginstal paket Jewel. Untuk menginstal Juno Jewel dalam, cukup ketik Pkg.add ( “Jewel”) , pilih teks, dan Catatan: . Setelah itu 2 + 2 berhasil.
  4. Anda telah berhasil menginstal Julia + Juno IDE. Sekarang Anda harus melakukan kode berikut untuk menginstal paket tambahan yang digunakan dalam latihan ekonometrik berikut:
 Pkg.update () Pkg.add (& amp; amp; quot; DataFrames & amp; amp; quot;) Pkg.add (& amp; amp; quot; pengganggu & amp; amp; quot;) Pkg.add ( & amp; amp; quot; GLM & amp; amp; quot;) Pkg.add (& amp; amp; quot; KernelEstimator & amp; amp; quot;) Pkg.add (& amp; amp; quot; Optim & amp; amp; quot;) Pkg.add (& amp; amp; quot; CPPI & amp; amp; quot;) Pkg .build (& amp; amp; quot; CPPI & amp; amp; quot;) Pkg.add (& amp; amp; quot; Jump & amp; amp ; quot;) Pkg.build (& amp; amp; quot; Jump & amp; amp; quot;) 

2. Tentukan tantangan ekonomi structural

untuk memotivasi kami aplikasi, kami mempertimbangkan model bisnis yang sangat sederhana, saya belajar di awal mahasiswa matematika ekonomi di Universitas Chicago. Meskipun model ini analitis sederhana, ekonometrik menjadi rumit cukup untuk memastikan Moments metode simulasi, melayani kita kasus mendidik

atau  c_i GEQ 0 konsumsi dan menunjukkan  0 l_i Leq Leq 1 acara hiburan. Pertimbangkan agen yang ingin memaksimalkan konsumsi Cobb-Douglas utilitas dan rekreasi, yaitu,

 U (c_i, l_i) = l ^ c ^ {gamma} 1 gamma_i _i.

di mana 0 Leq Leq gamma 1 adalah preferensi untuk konsumsi. batasan anggaran yang diberikan oleh

Leq (1- tau) w_i c_i (1-l_i) + epsilon_i

ketika w_i adalah upah yang diamati dalam data,  epsilon_i adalah pendapatan lain yang tidak diamati dalam data, dan  tau adalah tarif pajak

masalah agen adalah untuk memaksimalkan  U (c_i, l_i) tunduk keterbatasan anggaran. Kami berasumsi bahwa pendapatan non-tenaga kerja tidak berhubungan dengan tawaran gaji, sehingga mathbb {E} [epsilon_i | w_i] = 0. Meskipun asumsi ini kurang realistis, kami berharap gaji tinggi kecenderungan untuk memiliki pendapatan non-upah yang lebih tinggi, membantu menjaga contoh sederhana. Model ini juga dibangun di atas kecil yang kita memperlakukan tarif pajak sebagai diamati, tapi itu hanya tugas kita lebih sulit.

Tujuannya adalah untuk mengidentifikasi parameter model Econometer  gamma dan  tau Data (c_i, l_i, w_i) Key ^ {i = 1} dan diasumsikan struktur. Secara khusus, Econometer tertarik dalam menetapkan di mana

psi (w_i) equiv mathbb {E} _ {epsilon} frac {parsial} {parsial tau} C (w_i, epsilon, gamma, tau)

dan  C (cdot) menunjukkan permintaan konsumen. psi (w_i) adalah marginal propensity untuk memimpin agen  w_i untuk makan dalam menanggapi tarif pajak. psi bar {} adalah rata-rata kecenderungan mengkonsumsi marjinal penduduk dalam menanggapi tarif pajak. Tentu saja, kita bisa memecahkan model analisis untuk menemukan bahwa  psi (w_i) = - gamma w_i dan di mana  bar {w} adalah gaji rata-rata, tapi kami akan menunjukkan bahwa metode numerik mencapai jawaban yang benar ketika kita tidak bisa memecahkan model.



3 generasi, manajemen dan visualisasi regresi

kode pengulangan untuk bagian ini tersedia di sini.

Untuk menghasilkan data yang mengikuti model di atas, kita memecahkan pertama analisis fungsi dalam permintaan untuk konsumsi dan rekreasi. Secara khusus, mereka

C (w_i, epsilon_i, gamma, tau) = gamma (1- tau) + gamma w_i epsilon_i

L (w_i, epsilon_i, gamma, tau) = (1- gamma) + frac {(1- gamma) epsilon_i} {(1-tau) w_i}

cara ini, kita perlu nilai-nilai mendapatkan judul dan  epsilon_i , dan memilih nilai parameter  gamma dan  tau untuk menghasilkan nilai-nilai  c_i dan  l_i agen di model ini akan menyelesaikan Kami menerapkannya ke Julia sebagai berikut:

 ####### ###### ### Mengatur parameter simulasi srand (123) # mengatur benih untuk memastikan reproduktifitas N = 1000 # jumlah agen dalam gamma ekonomi = 0,5 # set Cobb-Douglas keuntungan lebih tau = 0,2 # konsumsi tarif pajak keseluruhan ## ##### Menggambar Data pendapatan yang optimal dan konsumsi dan rekreasi ######### epsilon = rand (N) # menggambar bertanda karyawan non-pekerjaan berpenghasilan = 10 + rand (N) # menggambar gaji melihat consum = gamma * (1-tau) * gaji + gamma * epsilon # permintaan Cobb-Douglas untuk = rekreasi c (1.0-gamma) + ((1,0-gamma) * epsilon) ./ ((1,0-tau) * gaji) menuntut # Cobb-Douglas untuk 

kode ini relatif mudah. ​​parameter pemilu kita adalah  N = 1000 epsilon_i sim mathcal {N} (0,1)  gamma = 1/2 dan  tau = 1/5 di Kami menggambar distribusi upah bersih w_i sim mathcal {N} (10.1) tapi ini sewenang-wenang.

Kami menggabungkan variabel dalam . bingkai data, dan ekspor data sebagai file CSV untuk lebih memahami data, kita mundur tidak parametrically  c_i di  w_i , dan plot hasilnya dengan kode pengganggu Julia adalah sebagai berikut:

 ####### Mengatur, menjelaskan, dan data ekspor menggunakan DataFrames oleh pengganggu ######### DF = dataframe (= consum consum, rekreasi = rekreasi, upah = upah, epsilon = epsilon) # framework dibuat plot_c data = plot (df, x =: gaji, y =: consum, Geom.smooth (= metode: loess)) # Plot E [consum | gaji] menggunakan pengganggu menggambar (SVG (& amp; amp; quot; plot_c.svg & amp; amp; quot ;, 4inch, 4inch) plot_c) bidang # export SVG writetable (& amp; amp; quot; consump_leisure.csv & amp; amp; quot;, df) ekspor # CSV data  

lagi, kode ini Gambar regresi eksplisit dihasilkan oleh tata letak fungsi adalah:

 plot_c


4. simulasi numerik dari pembatasan perilaku agen optimal

kode pengulangan untuk bagian ini tersedia di sini.

Kami sekarang menggunakan optimasi numerik yang terbatas untuk menghasilkan konsumsi dan hiburan terbaik tanpa solusi analitis fungsi aplikasi. Kita mulai dengan mengimpor data dan paket yang dibutuhkan:

 Persiapan ####### ## ####### angka DataFrames optimasi digunakan oleh melompat menggunakan DF = readtable CPPI (& amp; amp; quot; consump_leisure.csv & amp; amp; quot;) N = ukuran (df) [1] 

menggunakan sintaks melompat untuk pemodelan nonlinier, pertama kita mendefinisikan template kosong terkait dengan CPPI solver dan menambahkan  nilai  c_i dan nilai  l_i gaya

 m = Model (IpoptSolver solver = ()) # menentukan model putih dipilih oleh algoritma @defVar CPPI (m, c [i = 1: N] & amp; amp; gt; = 0) #define positif setiap konsumsi agen @defVar (m, 0 & amp; amp; lt; = l [i = 1: N] & amp; amp; lt; = 1) #define rekreasi [0,1] untuk setiap agen 

sintaks ini sangat nyaman karena memungkinkan kita untuk menentukan parameter dari vektor, masing-masing dengan rintangan alam memuaskan ketidaksamaan berikut, kita mendefinisikan kendala anggaran, yang juga mengikuti sintaks yang tepat:

 @addConstraint (m, c [i = 1: N] == .. (1,0 t) * (1.0-l [i]) * w [i] + dan [i]) masing-masing # agen harus memenuhi kendala anggaran 

Akhirnya, kita mendefinisikan fungsi target skalar, yang merupakan jumlah dari setiap layanan:

 @setNLObjective (m, Max, kuantitas {g * log (c [i]) + (1-g) * log (l [i]), i = 1, N}) # memaksimalkan jumlah layanan semua agen 

Perhatikan bahwa kita dapat mengoptimalkan situs dioptimalkan fungsi target  fungsi karena tujuan memaksimalkan masalah individu yang timbul adalah independen dari semua individu, sehingga jumlah maksimum. jumlah maksimum Akhirnya, kita dapat menerapkan model ini dan solver untuk mengekstrak konsumsi optimal dan alamat sebagai berikut:

 status = tekad (m) # didorong optimasi numerik c_opt = getValue (c) permintaan untuk c # ekstrak l_opt = getValue (l) permintaan untuk ekstrak # 

memastikan bahwa ia bekerja membandingkan konsumsi ini berasal dari akses digital publik yang besar dihasilkan sebelumnya menggunakan fungsi dari permintaan yang sebenarnya:

 cor (c_opt, array (df [: consum])) 9999999998435865 

Dengan cara ini, nilai-nilai konsumsi optimizer yang dihasilkan oleh pendekatan numerik dengan permintaan konsumsi hampir identik dengan diproduksi oleh permintaan konsumen yang sebenarnya. Masukan itu semua bersama-sama, kami telah membuat sebuah fungsi yang dapat memecahkan untuk konsumsi optimal dan alamat yang diberikan nilai-nilai khusus  gamma  tau dan epsilon

 fungsi hh_constrained_opt (g, t, w, e) = m Model (IpoptSolver solver = ()) # menentukan rancangan model yang diselesaikan dengan algoritma CPPI @defVar (m, c [i = 1: N] & amp; amp; gt; = 0) #define positif untuk setiap @defVar konsumsi agen (m, 0 & amp; amp; lt; = l [i = 1: N] & amp; amp; lt; = 1) # berlokasi rekreasi [0,1] untuk setiap @ agen addConstraint (m, c [i = 1: N] == (1,0 t) * (1.0-l [i]) * w [i] + dan [i ]) # setiap agen harus memenuhi batasan anggaran @ setNLObjective (m, Max, kuantitas {g .. * log (c [i]) + (1-g) * log (l [i]), i = 1 , N}) # memaksimalkan jumlah layanan di setiap agen negara = tekad (m) # digital optimasi run c_opt = getValue (c) aplikasi # ekstrak ke c l_opt = permintaan getValue (l) # ekstrak mencari = dataframe (c_opt = c_opt, l_opt = l_opt) # mengembalikan query sebagai hh_constrained_opt dataframe akhir (gamma, tau, array (df [: upah]), array (df [epsilon])) # memverifikasi bahwa ia bekerja dalam nilai-nilai nyata gamma , tau, dan epsilon 

5. diparalelkan simulasi metode evaluasi

kode replikasi untuk bagian ini tersedia di sini.

Kami telah melihat di bagian sebelumnya bahwa untuk satu set parameter model  gamma dan  tau dan menggambar mengingat epsilon_ {i} setiap  i kita memiliki informasi yang cukup untuk simulasi c_ {i} dan  L_ {i} setiap  i . Masukkan nilai simulasi dari hat {c} _ {i} kiri (epsilon, gamma, tau kanan) dan hat {L} _ {i} kiri (epsilon, gamma, tau kanan). dengan mereka, kita dapat menentukan waktu

hat {m} kiri (gamma, tau kanan) = mathbb {E} _ {epsilon} meninggalkan [mulai {array yang} {c} frac {1} {N} sum_ {i} meninggalkan [hat {c} _ {i} kiri (epsilon kanan) -c_ {i} kanan] frac {1} {N} sum_ {i} meninggalkan [hat {s} _ {i} kiri (epsilon kanan) -l_ {i} kanan] end {array yang} kanan]

yang merupakan nol di bawah asumsi dari model. Sebuah metode simulasi momen (MSM) akses mengevaluasi gamma dan  tau kemudian adalah

left(hat{gamma},hat{tau}right)=argmin_{gammainleft[0,1right],tauinleft[0,1right]}hat{m}left(gamma,tauright)'What{m}left(gamma,tauright)

ketika  W  2 times2 matrix tertimbang, yang hanya penting ketika jumlah kali melebihi jumlah parameter yang tidak benar dalam kasus kami, sehingga  W dapat diabaikan dan menyederhanakan metode momen simulasi,

kiri (hat {gamma}, {tau} hat kanan) = {gammainleft argmin_ [0,1right] tauinleft [0,1right] mathbb {kiri} {E} _ {epsilon} meninggalkan [frac {1} {N} sum_ {i} meninggalkan [hat {c} _ {i} kiri (epsilonright) -c_ {i} kanan] kanan] kanan} ^ {2} + {mathbb meninggalkan {E} _ {epsilon} meninggalkan [frac {1} {N} sum_ {i} meninggalkan [hat {s} _ {i} kiri (epsilonright) -l_ {i} kanan] kanan] kanan} ^ {2}

dengan asumsi bahwa kita mengetahui distribusi  epsilon_i kita hanya dapat menarik lebih banyak nilai  epsilon_i setiap  i , dan rata-rata waktu bersama melalui semua keran  epsilon_i Integrasi ini Monte Carlo Dalam digital Julia, kita bisa Kami mengatur fungsi target ini dengan hasil imbang dari epsilon sebagai berikut:

 sim_moments fungsi (parameter) this_epsilon = rand (N) # imbang ggamma acak Epsilon, ttau = Pengaturan # menggambar gamma dan tau oleh this_demand = hh_constrained_opt vektor (ggamma, ttau, array (df [: upah]) this_epsilon) # menerima permintaan untuk c dan c_moment = rata-rata (this_demand [: c_opt]) - alat (df [: consum]) # komputasi instan c l_moment empiris = rata (this_demand [: l_opt]) - berarti (df [: rekreasi ]) # komputasi saat empiris untuk [c_moment, saat l_moment] # kembalinya vektor akhir 

untuk mengevaluasi hat {m} kiri (gamma, tau kanan) kita harus mengeksekusi sim_moments (parameter) beberapa kali dan mengambil rata-rata semua orang bijaksana untuk mencapai harapan melalui  epsilon_i untuk setiap perhitungan komputer yang intensif, masuk akal untuk menghitung kontribusi {m} hat kiri (gamma, tau kanan) untuk setiap menggambar di prosesor yang berbeda kemudian rata-rata mereka.

Ada, saya mempresentasikan pendekatan yang tepat untuk Julia paralelisasi. idenya adalah untuk meluncurkan prosesor addprocs () fungsi dalam script "luar "dan kemudian mengimpor semua data dan fungsi yang diperlukan untuk semua berbeda membutuhkan prosesor function () diterapkan pada naskah" insider ", di mana data dan fungsi yang diperlukan dikelola dalam script. itu terlalu mudah dan jauh lebih mudah daripada manual benih dan-mengambil pendekatan yang disarankan oleh dokumentasi resmi Julia.

untuk menerapkan metode diparalelkan kali fungsi simulasi hh_constrained_opt () dan sim_moments () disimpan dalam file bernama est_msm_inner .jl. Set kode berikut meminimalkan paralel sasaran MSM MSM menggunakan perintah telah memutuskan untuk mengoptimalkan algoritma Nelder-Mead digunakan oleh paket OPTIM:

 Persiapan paralelisasi ####### ######### addprocs (3) # 3 menambahkan prosesor paralel (yang pertama ditambahkan secara default) cetak (nprocs ()) # sekarang memiliki 4 prosesor aktif memerlukan (& amp; amp; quot; est_msm_inner.jl & amp; amp; quot;) ini mendistribusikan fungsi dan data untuk semua prosesor yang aktif ##### ## Squared Set jumlah sampah ####### # # fungsi parallel_moments paralel (parameter) parameter = exp (parameter) ./ (1,0 + exp (parameter)) parameter # akan rescaled [ 0,1] = @parallel hasil (HCAT) untuk i = 1: numReps sim_moments (parameter) akhir avg_c_moment = rata (hasil [1:]) avg_l_moment = rata (hasil [2]) avg_c_moment SSR = ^ 2 ^ 2 + end avg_l_moment ####### Mengurangi jumlah sampah Squared ### ###### paralel dengan menggunakan MSM OPTIM () memilih = (,, parallel_moments metode = [0, 0] nelder_mead, FTOL = 1E-8) System.out.println (keluar) # cek exp konvergensi (out.minimum) ./(1.0+exp(out.minimum)) # mengembalikan hasil di akhir unit dijadwal ulang 

paralelisasi dilakukan oleh makro @parallel, dan hasilnya digabungkan secara horizontal dengan prosesor yang berbeda dengan perintah HCAT. Berikut numReps yang tala parameter, yang merupakan jumlah cetak  epsilon untuk digunakan dalam integrasi numerik Monte Carlo. Karena contoh sangat sederhana, sejumlah kecil pengulangan cukup, sehingga lebih banyak akan dibutuhkan jika  epsilon masukkan model dalam cara yang lebih rumit . Proses tersebut adalah sebagai berikut dan membutuhkan 268 detik untuk berjalan di Macbook Air:

 = 12 # numReps memutuskan beberapa kali untuk mensimulasikan Epsilon gamma_MSM, tau_MSM MSM = () # Lakukan gamma_MSM MSM, tau_MSM 49994494921381816, 19992279518894465 

Akhirnya, mengingat perkiraan MSM

Leave a Reply

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>