Lebih

Menggunakan Python, keluaran Proyek Batch tidak akan masuk ke kumpulan data fitur?


Saat mencoba mengelompokkan proyek di ArcGIS 9.3 atau 10 (menggunakan arcpy atau arcgisscripting), saya tidak dapat memasukkan hasil geoproses ke dalam kumpulan data fitur yang saya tentukan. Hasilnya malah dijatuhkan di root Geodatabase (*.mdb).

Berikut adalah versi singkat dari apa yang saya miliki sejauh ini:

import arcgisscripting, os gp = arcgisscripting.create(9.3) #set tanggal dmy = datetime.now() currentDate = str(dmy.month) + "-" + str(dmy.day) + "-" + str(dmy. year) outputfolder = gp.getparameterastext(0) #di mana kita akan meletakkan gdb citydata = gp.getparameterastext(1) gp.workspace = outputfolder projectedfolder = os.path.join(outputfolder, "projected") gp.CreateFolder_management (*os.path.split(projectedfolder)) gdb = "Projected_Data_" + currentDate + ".mdb" #set sistem koordinat outputCS = gp.CreateObject("SpatialReference") outputCS.createFromFile(os.path.join(gp.getinstallinfo) ()['InstallDir'], "Coordinate SystemsGeographic Coordinate SystemsNorth AmericaNAD 1983.prj")) transformation = "" gp.AddMessage("Membuat kumpulan data fitur Kota") gp.CreateFeatureDataset(os. path.join(projectedfolder, gdb), "City", outputCS) gp.AddMessage("Memuat di kelas fitur Kota") arcpy.BatchProject_management(citydata, os.path.join(projectedfolder, gdb, "City"), outputCS, "", transformasi)

Jelas, bagian yang bermasalah dengan saya adalah Jalur Keluaran di baris terakhir. Saya juga telah membuat hard-code path ke dataset fitur "City", tetapi masih menjatuhkannya di root. Ada ide?

(Diposting silang di Forum ESRI di sini)


Banyak orang yang bertanya tentang hal ini. Setidaknya satu permintaan (NIM013677) telah ditolak dengan status "sesuai desain". Alasan yang diberikan adalah:

Karena saat menggunakan versi skrip, alat tidak dapat mengetahui apakah targetnya adalah dataset atau kelas fitur. Ini dirancang untuk tidak mendukung kumpulan data fitur.

Penafian Std: Saya bekerja di Esri, tetapi tidak di tim geoprosesing (yang membuat keputusan ini).


Ini diperbaiki di ArcGIS 10.1: http://forums.arcgis.com/threads/39448-Using-Python-can-t-get-Batch-Project-outputs-to-save-in-a-feature-dataset?p =244841&viewfull=1#post244841

Saya mengujinya di Jendela Python di ArcMap 10.1, berfungsi :-)


Sepanjang dokumentasi kami menganggap Anda menggunakan virtualenv untuk mengelola lingkungan Python Anda. Pengaturan ini adalah yang digunakan dan direkomendasikan oleh penulis proyek dan merupakan cara termudah untuk memastikan Anda tidak mengalami masalah lingkungan. Jika Anda menggunakan Anaconda, Miniconda atau Mamba, pertama-tama baca instruksi di Pelatihan dari lingkungan Anaconda atau miniconda lalu lanjutkan dari langkah penginstalan di bawah ini.

Dalam membuat lingkungan virtual, Anda akan membuat direktori yang berisi biner python3 dan semua yang diperlukan untuk menjalankan deepspeech. Anda dapat menggunakan direktori apa pun yang Anda inginkan. Untuk keperluan dokumentasi, kita akan mengandalkan $HOME/tmp/deepspeech-train-venv . Anda dapat membuatnya menggunakan perintah ini:

Setelah perintah ini berhasil diselesaikan, lingkungan akan siap untuk diaktifkan.


Pengantar

Bagi mereka yang memulai di lingkungan Optical Character Recognition (OCR), saya merasa menarik untuk membawa konteks singkat.

Menurut [1], sistem OCR memiliki dua kategori: on line, di mana informasi input diperoleh melalui sensor penulisan waktu nyata dan offline, di mana informasi input diperoleh melalui informasi statis (gambar). Dalam offline kategori, ada pengenalan teks yang diketik dan naskah (Gambar 1).

Jadi, Handwriting Text Recognition (HTR) memiliki tujuan untuk menyalin teks kursif ke media digital (ASCII, Unicode) [2].

Selama bertahun-tahun, sistem HTR telah menggunakan Hidden Markov Models (HMM) untuk tugas transkripsi [3]–[5], tetapi baru-baru ini, melalui Deep Learning, pendekatan Convolutional Recurrent Neural Networks (CRNN) telah digunakan untuk mengatasi beberapa keterbatasan. dari HMM [6], [7]. Untuk mencontohkan model CRNN, saya membawa model [8] (Gambar 2).

Alur kerja dapat dibagi menjadi 3 langkah. Langkah 1: gambar input dimasukkan ke dalam lapisan CNN untuk mengekstrak fitur. Outputnya adalah peta fitur. Langkah 2: melalui implementasi Long Short-Term Memory (LSTM), RNN mampu menyebarkan informasi jarak yang lebih jauh dan menyediakan fitur yang lebih kuat untuk pelatihan. Langkah 3: dengan matriks keluaran RNN, Connectionist Temporal Classification (CTC) [9] menghitung nilai kerugian dan juga menerjemahkan kode ke dalam teks akhir.

Untuk detail lebih lanjut tentang proses ini, saya sarankan membaca Membangun Sistem Pengenalan Teks Tulisan Tangan menggunakan TensorFlow oleh Harald Scheidl (2018).

Akhirnya, sangat penting jelaskan itu untuk posting ini, langkah 3 (CTC) sama untuk semua arsitektur yang disajikan, maka digunakan metode Vanilla Beam Search [10], karena tidak memerlukan kamus untuk penerapannya, tidak seperti metode lain yang dikenal seperti Token Passing [11] dan Pencarian Berkas Kata [8]. Oleh karena itu, arsitektur yang disajikan di bagian berikut hanya bertindak dalam langkah 1 dan 2.

Selain itu, rangkaian karakter untuk teks encoding juga sama untuk semua dataset. Jadi, daftar yang digunakan terdiri dari 95 karakter yang dapat dicetak dari tabel ASCII (Gambar 3) secara default dan tidak mengandung huruf beraksen.

Sekarang Anda mungkin bertanya-tanya mengapa menggunakan CTC dan charset yang sama untuk arsitektur dan dataset. Nah, untuk eksperimen ini, saya ingin membawa pendekatan yang lebih seragam antara model dan database. Karena penggunaan kamus dan rangkaian karakter tertentu dapat memberikan hasil yang lebih baik dalam beberapa skenario, tetapi tidak begitu banyak pada skenario lainnya. Misalnya, rangkaian karakter dengan hanya 60 karakter "lebih mudah dipukul" (1/60) daripada yang lain dengan 125 (1/125). Bahkan, pendekatan di sini menjadi lebih sulit untuk pengenalan teks oleh model.


Tentukan Fungsi Skor Anomali

Selanjutnya, kita perlu mendefinisikan fungsi yang menghitung seberapa anomali setiap transaksi. Semakin anomali transaksinya, semakin besar kemungkinannya untuk menjadi penipuan, dengan asumsi bahwa penipuan jarang terjadi dan terlihat agak berbeda dari sebagian besar transaksi, yang normal.

Seperti yang telah kita bahas di bab sebelumnya, algoritme reduksi dimensionalitas mengurangi dimensionalitas data sambil mencoba meminimalkan kesalahan rekonstruksi. Dengan kata lain, algoritma ini mencoba untuk menangkap informasi yang paling menonjol dari fitur asli sedemikian rupa sehingga mereka dapat merekonstruksi set fitur asli dari set fitur yang dikurangi sebaik mungkin. Namun, algoritme pengurangan dimensi ini tidak dapat menangkap semua informasi dari fitur asli saat mereka pindah ke ruang dimensi yang lebih rendah oleh karena itu, akan ada beberapa kesalahan karena algoritme ini merekonstruksi set fitur yang direduksi kembali ke jumlah dimensi asli.

Dalam konteks dataset transaksi kartu kredit kami, algoritme akan memiliki kesalahan rekonstruksi terbesar pada transaksi yang paling sulit untuk dimodelkan—dengan kata lain, transaksi yang paling jarang terjadi dan paling anomali. Karena penipuan jarang terjadi dan mungkin berbeda dari transaksi normal, transaksi penipuan harus menunjukkan kesalahan rekonstruksi terbesar. Jadi mari kita definisikan skor anomali sebagai kesalahan rekonstruksi. Kesalahan rekonstruksi untuk setiap transaksi adalah jumlah perbedaan kuadrat antara matriks fitur asli dan matriks yang direkonstruksi menggunakan algoritma pengurangan dimensi. Kami akan menskalakan jumlah perbedaan kuadrat dengan rentang maks-min dari jumlah perbedaan kuadrat untuk seluruh kumpulan data, sehingga semua kesalahan rekonstruksi berada dalam rentang nol hingga satu.

Transaksi yang memiliki jumlah selisih kuadrat terbesar akan memiliki kesalahan mendekati satu, sedangkan transaksi yang memiliki jumlah selisih kuadrat terkecil akan memiliki kesalahan mendekati nol.

Ini harus akrab. Seperti solusi deteksi penipuan terawasi yang kami buat di Bab 2, algoritme pengurangan dimensi akan secara efektif menetapkan skor anomali antara nol dan satu untuk setiap transaksi. Nol adalah normal dan satu anomali (dan kemungkinan besar adalah penipuan).


Menggunakan Python, keluaran Proyek Batch tidak akan masuk ke kumpulan data fitur? - Sistem Informasi Geografis

Rekayasa Fitur Otomatis dan Penilaian Model menggunakan IBM Watson Studio Lokal Studio

Tujuan dari pola kode ini adalah untuk menunjukkan bagaimana ilmuwan data dapat memanfaatkan Watson Studio Local IBM untuk mengotomatisasi:

Ekstraksi fitur secara berkala (digunakan untuk melatih model pembelajaran mesin) dari set data terdistribusi.

Skor batch dari fitur yang diekstraksi pada model yang digunakan.

Untuk mengilustrasikan hal ini, contoh alur kerja ilmu data yang mengklasifikasikan 3 kategori anggur berbeda dari sifat kimia anggur tersebut digunakan dalam pola kode ini.

Untuk ekstraksi fitur, Analisis komponen utama (PCA) diterapkan pada dataset klasifikasi anggur dan dua komponen utama diekstraksi.

Untuk model klasifikasi, regresi Logistik (model pembelajaran mesin yang populer) diterapkan pada komponen yang diekstraksi untuk memprediksi kategori anggur.

Apa itu PCA? Analisis komponen utama (PCA) adalah teknik pengurangan dimensi populer yang digunakan untuk mereduksi N sejumlah variabel numerik menjadi beberapa komponen utama yang digunakan sebagai fitur dalam model pembelajaran mesin. Komponen utama ini menangkap persentase utama dari efek varians gabungan dari semua variabel.

Apa itu IBM Watson Studio Lokal? Watson Studio Local adalah solusi di tempat untuk ilmuwan data dan insinyur data. Ini menawarkan seperangkat alat ilmu data yang terintegrasi dengan teknologi notebook RStudio, Spark, Jupyter, dan Zeppelin.

Apa itu Pembelajaran Mesin IBM Watson? Watson Machine Learning adalah alat Watson Studio Lokal yang memberi pengguna kemampuan untuk membuat dan melatih model pembelajaran mesin. Pengguna juga dapat menerapkan model mereka agar tersedia untuk audiens yang lebih luas.

Repo ini berisi dua notebook Jupyter yang menggambarkan cara mengekstrak fitur dan membangun model pada kumpulan data klasifikasi anggur. Data berisi daftar anggur dengan fitur kimia terkait dan klasifikasi anggur yang ditetapkan. Ada tiga skrip dalam repo untuk mengotomatiskan ekstraksi fitur, menilai fitur yang diekstraksi, dan menggabungkan dua langkah masing-masing sebagai satu pembungkus.

Notebook pertama menggunakan teknik rekayasa fitur seperti PCA dan penskalaan standar untuk mengekstrak fitur pengembangan model dari kumpulan data wine.

Notebook kedua melatih, membuat, dan menyimpan model yang dapat dinilai. Model kemudian dapat digunakan dan diakses dari jarak jauh.

Skrip pertama hanyalah replika dari notebook pertama sebagai skrip .py yang dapat dijadwalkan untuk mengekstrak fitur secara berkala dan menyimpannya dengan nomor versi.

Skrip kedua digunakan untuk menilai kumpulan fitur yang diekstraksi pada model yang diterapkan dan menyimpan hasilnya dengan pembuatan versi.

Skrip ketiga hanyalah skrip pembungkus yang menjalankan dua skrip di atas satu demi satu dan digunakan untuk mengotomatiskan ekstraksi fitur dan penilaian model dalam satu proses.

Menggunakan fitur Watson Machine Learning di Watson Studio, ketiga skrip digunakan sebagai layanan untuk mengotomatiskan ekstraksi fitur dan penilaian dalam produksi.

Setelah Anda menyelesaikan pola kode ini, Anda akan memahami cara:

  • Gunakan Watson Studio Local dan untuk mengekstrak fitur menggunakan PCA dan teknik lainnya.
  • Bangun, Latih, dan Simpan model dari fitur yang diekstraksi menggunakan Watson Studio Lokal.
  • Gunakan fitur Watson Machine Learning untuk menerapkan dan mengakses model Anda dalam mode batch dan API
  • Mengotomatiskan ekstraksi fitur dan penilaian model menggunakan skrip yang disebarkan sebagai layanan dalam mode batch dan API.

  1. Kumpulan data klasifikasi anggur dimuat ke Watson Studio Local sebagai aset.
  2. Pengguna berinteraksi dengan Watson Studio Local untuk mengakses aset seperti notebook Jupyter, skrip python, dan kumpulan data.
  3. Notebook Jupyter menggunakan operasi Spark DataFrame untuk membersihkan kumpulan data dan menggunakan Spark MLlib untuk melatih model klasifikasi PCA.
  4. Model dan skrip yang menyertainya disebarkan dan dijalankan dari Watson Machine Learning.
    : Solusi di tempat yang out-of-the-box untuk ilmuwan data dan insinyur data. Ia menawarkan seperangkat alat ilmu data yang terintegrasi dengan teknologi notebook RStudio, Spark, Jupyter, dan Zeppelin. : Sistem komputasi cluster open-source, cepat, dan serba guna. : Aplikasi web sumber terbuka yang memungkinkan Anda membuat dan berbagi dokumen yang berisi kode langsung, persamaan, visualisasi, dan teks penjelasan.
    : Kecerdasan buatan dapat diterapkan ke berbagai ruang solusi untuk menghadirkan teknologi yang mengganggu. : Python adalah bahasa pemrograman yang memungkinkan Anda bekerja lebih cepat dan mengintegrasikan sistem Anda dengan lebih efektif.

Instal Watson Studio Lokal

Watson Studio Local menyediakan seperangkat alat ilmu data, seperti notebook Spark dan Jupyter, yang diperlukan untuk melengkapi pola kode ini. Baca Panduan Instalasi untuk menginstal dan mengonfigurasi instans Watson Studio Lokal Anda.

Ikuti langkah-langkah ini untuk menyiapkan lingkungan yang tepat untuk menjalankan notebook kami secara lokal.

2. Buat proyek di IBM Watson Studio Lokal

Di Watson Studio Local, kami menggunakan proyek sebagai wadah untuk semua aset terkait kami. Untuk membuat proyek:

Setelah dibuat, Anda dapat melihat semua aset proyek dengan memilih tab Aset dari halaman beranda proyek.

Untuk proyek kami, kami perlu menambahkan buku catatan dan skrip kami. Untuk menambahkan buku catatan kami:

Pilih Buku Catatan di daftar Aset proyek, lalu tekan tombol Tambahkan Buku Catatan.

Masukkan nama buku catatan unik dan gunakan opsi Dari URL untuk memuat buku catatan dari repo github.

Pilih Lingkungan yang berjalan di bawah Python v3.1 atau lebih tinggi.

CATATAN: Untuk memudahkan mengikuti petunjuk selanjutnya, Anda disarankan untuk mengatur Nama agar sesuai dengan nama buku catatan dalam file yang diunggah.

  • Klik pada tab From File dan kemudian gunakan opsi Drag and Drop untuk memuat file skrip dari repo lokal Anda. Nama skrip akan diisi sebelumnya dengan nama file yang diunggah. Pilih Python versi 3.

Dari tab File Lokal, klik tombol Pilih dari sistem file lokal Anda untuk memilih file /data/Wine.csv dari repo lokal Anda.

4. Jalankan notebook untuk membuat model kami

Untuk melihat buku catatan kami, pilih Buku Catatan di daftar Aset proyek.

Pertama, beberapa latar belakang tentang cara menjalankan notebook:

  • Kosong, ini menunjukkan bahwa sel belum pernah dieksekusi.
  • Angka, angka ini mewakili urutan relatif langkah kode ini dijalankan.
  • A * , yang menunjukkan bahwa sel sedang dieksekusi.
  • Satu sel pada satu waktu.
    • Pilih sel, lalu tekan tombol Putar di toolbar.
    • Dari bilah menu Sel, ada beberapa opsi yang tersedia. Misalnya, Anda dapat Menjalankan Semua sel di buku catatan, atau Anda dapat Menjalankan Semua Di Bawah , yang akan mulai mengeksekusi dari sel pertama di bawah sel yang dipilih saat ini, lalu melanjutkan mengeksekusi semua sel berikutnya.
    • Tekan tombol Jadwal yang terletak di bagian kanan atas panel notebook Anda. Di sini Anda dapat menjadwalkan buku catatan Anda untuk dieksekusi sekali di waktu mendatang, atau berulang kali pada interval yang Anda tentukan.

    Untuk menjalankan buku catatan, cukup klik nama buku catatan dari daftar Buku Catatan.

    Jalankan notebook pca-features terlebih dahulu. Itu membaca dan mengubah kumpulan data anggur. Itu juga membuat file data yang akan dibutuhkan oleh notebook berikutnya. File data csv ini dapat dilihat dengan memilih Kumpulan data dari daftar Aset proyek.

    Jalankan notebook pemodelan pca, yang menghasilkan dan menyimpan model data kami.

    Setelah model dibuat, Anda dapat melihatnya dengan memilih Model di daftar Aset proyek. Perhatikan bahwa itu diberikan nomor versi default.

    Catatan: Setelah menjalankan buku catatan, Anda mungkin bertanya-tanya mengapa kami tidak menggabungkan semua kode menjadi satu buku catatan saja. Alasannya hanya untuk memisahkan langkah-langkah pemrosesan data dari langkah-langkah pembuatan model. Ini memungkinkan kami untuk memproses data baru apa pun di masa mendatang tanpa memengaruhi model kami saat ini. Faktanya, inilah tepatnya yang harus dilakukan dengan data baru apa pun - skor terhadap model saat ini terlebih dahulu untuk menentukan apakah hasilnya masih dapat diterima. Jika tidak, kita dapat menjalankan notebook kedua untuk menghasilkan model baru.

    Seperti yang akan Anda lihat nanti, menjalankan notebook pertama akan dilakukan dengan menjalankan skrip di proyek kami ( scripts/feature_engineering.py ). Skrip ini awalnya dibuat dengan memuat notebook pca-features ke Jupyter, kemudian mengekspor sel notebook ke dalam skrip python (gunakan opsi menu File -> Download as -> Python (.py) ). Kami hanya perlu sedikit memodifikasi skrip untuk memasukkan beberapa kode untuk menangani pembuatan versi data.

    5. Lakukan perubahan pada Repositori Master Lokal Watson Studio

    Setelah membuat perubahan pada proyek Anda, Anda kadang-kadang akan diingatkan untuk melakukan dan mendorong perubahan Anda ke Repoisory Master Lokal Watson Studio.

    Sekarang kita telah menambahkan buku catatan dan skrip kita, dan membuat model kita, mari kita lanjutkan dan lakukan itu. Komit dan dorong semua aset baru kami, dan setel tag versi ke v1.0 .

    6. Buat proyek rilis di IBM Watson Machine Learning

    IBM Watson Machine Learning menyediakan mekanisme untuk menyebarkan model kami sebagai layanan web. Ini mengelola Rilis Proyek, yang sekarang akan kita buat.

    • Luncurkan alat IBM Watson Machine Learning dengan memilihnya dari menu tarik-turun utama di halaman beranda Watson Studio Local.

    • Pilih proyek komitmen kami sebelumnya dari daftar drop-down proyek Sumber, dan pilih tag versi yang Anda tetapkan untuk proyek. Beri rilis tersebut Nama dan Rute (yang dapat berupa string acak apa pun), dan tekan Buat .

    7. Terapkan model kami sebagai layanan web

    • Pilih model dari daftar Aset yang terkait dengan proyek kami. Dari panel detail model, tekan tombol layanan web.

    • Pada layar penerapan model, berikan nama unik, pesan beberapa CPU dan memori, lalu tekan Buat .

    8. Terapkan skrip kami sebagai pekerjaan

    • Pada layar penyebaran skrip, berikan nama pekerjaan, atur jenisnya ke Script run , tambahkan v1 sebagai argumen baris perintah, lalu tekan Create .

    Ulangi langkah ini untuk 2 skrip yang tersisa.

    9. Bawa penerapan secara online

    Jika Anda memilih tab Deployments dari halaman proyek, Anda akan melihat bahwa semua Deployments terdaftar sebagai dinonaktifkan.

    Untuk menghadirkan penerapan secara online, tekan ikon tombol Luncurkan, yang merupakan ikon paling kiri yang tercantum di bagian atas halaman. Setelah Anda menyelesaikan tindakan, Anda akan melihat yang berikut ini.

    Catatan: Anda mungkin harus secara manual Mengaktifkan penerapan model dengan menggunakan opsi menu yang tercantum di sisi kanan baris model dalam tabel penerapan.

    10. Kumpulkan data titik akhir API untuk digunakan dalam skrip

    Beberapa skrip kami akan memerlukan akses ke model yang kami terapkan dan, dalam beberapa kasus, ke skrip yang digunakan lainnya.

    Berikut adalah ikhtisar singkat tentang apa yang dilakukan dan dibutuhkan skrip kami:

    feature_engineering.py - skrip ini menjalankan fungsi yang sama dengan notebook fitur pca kami. Ini membaca data dari set data wine, lalu menerapkan teknik pembelajaran mesin untuk mengubah data. Outputnya akan menjadi dua file data - fitur dan target . Perhatikan bahwa file data ini akan memiliki tag versi yang ditambahkan ke dalamnya sehingga kontennya tidak ditulis berlebihan setiap kali skrip ini dijalankan. Skrip ini tidak memerlukan akses ke model kami atau skrip lainnya.

    model_scoring.py - skrip ini adalah prosesor batch. Ini membaca file data fitur dan menilai setiap fitur, satu per satu, dengan menjalankannya melalui model kami. Outputnya akan menjadi file data scoring_output. Perhatikan bahwa file data akan memiliki tag versi yang ditambahkan ke dalamnya sehingga isinya tidak terlalu banyak ditulis setiap kali skrip ini dijalankan. Skrip ini memerlukan akses ke model yang kami terapkan.

    extract_and_score.py - skrip ini dibuat untuk kenyamanan, dan dapat digunakan sebagai pengganti menjalankan skrip sebelumnya secara terpisah. Itu memanggil skrip feature_engineering terlebih dahulu, lalu ketika selesai, itu memanggil skrip model_scoring. Skrip ini memerlukan akses ke skrip yang digunakan lainnya.

    Untuk mengakses model atau skrip yang diterapkan, kita perlu mengumpulkan titik akhir API terkait dan token otorisasi. Semua nilai ini tersedia dari halaman penerapan untuk setiap objek. Titik akhir akan mengambil format berikut:

    • titik akhir model akan berakhiran /score .
    • titik akhir skrip akan diakhiri dengan /trigger , /status , atau /cancel (yang sesuai dengan tindakan: start , status , dan stop ).

    Untuk mendapatkan titik akhir untuk model yang kami terapkan, klik model dari tab Aset di halaman proyek.

    Titik akhir tercantum di bagian atas halaman. Endpoint dan Deployment Token dapat disimpan ke clipboard dengan mengklik masing-masing ikon.

    Ulangi langkah ini untuk mengambil titik akhir untuk skrip feature_engineering dan model_scoring.

    Catatan: Anda hanya perlu mendapatkan satu salinan Deployment Token . Ini akan sama untuk semua penerapan dalam proyek ini.

    11. Ubah skrip di Watson Studio Lokal

    Setelah kami mengumpulkan titik akhir penerapan dan token penerapan kami, kami harus kembali ke mode Watson Studio Lokal sehingga kami dapat memodifikasi dan menguji skrip kami.

    Buka daftar Aset untuk proyek, dan pilih Skrip . Klik pada file skrip untuk membukanya dalam mode edit.

    Skrip yang akan kita modifikasi adalah skrip yang mereferensikan objek penerapan. Ini adalah:

    • Untuk skrip model_scoring, gantikan nilai token dan endpoint, lalu simpan skrip versi baru.

    Untuk skrip extract_and_score, ganti dengan nilai token dan endpoint. Nilai titik akhir adalah untuk skrip penerapan feature_engineering dan model_scoring.

    Penting: Titik akhir akan diakhiri dengan string /trigger . Hapus bagian URL tersebut karena skrip akan menambahkan /trigger atau /status ke titik akhir, sesuai kebutuhan.

    Selesaikan dengan menyimpan versi baru skrip dengan mengklik ikon Simpan yang terletak di sisi kanan atas halaman.

    12. Jalankan skrip secara lokal untuk menguji

    Untuk menghindari keharusan bolak-balik antara Watson Studio Local dan Watson Machine Learning (yang mencakup re-deploy dan membuat versi rilis baru), pastikan skrip dijalankan secara lokal di Watson Studio Local terlebih dahulu.

    Skrip dapat dijalankan dari panel detail untuk skrip, atau dari editor skrip.

    Jalankan sebagai pekerjaan dari panel detail skrip:

    Mulailah dengan skrip feature_engineering . Gunakan bilah menu di sisi kanan baris skrip untuk Membuat Pekerjaan dan menjalankan skrip.

    Di panel Create Job run, berikan nama unik dan pastikan Anda menggunakan opsi berikut:

    • Jenis: Jalankan Skrip
    • Pekerja: Python 3
    • Aset sumber: /scripts/feature_engineering.py
    • Argumen baris perintah: v1
    • Dijadwalkan untuk dijalankan: Sesuai permintaan

    Setelah Anda menekan tombol Create, Anda akan melihat panel run.

    Jika Anda menggulir sedikit ke bawah, Anda akan melihat tombol Jalankan Sekarang. Klik untuk memulai skrip. Sekali lagi, Anda akan disajikan dengan dialog yang mengharuskan Anda memberikan nama run. Nilai lainnya akan ditetapkan secara default ke nilai yang telah Anda tetapkan, sehingga tidak perlu diubah. Klik tombol Jalankan untuk menjalankan skrip.

    Anda akan ditransfer kembali ke panel run di mana Anda dapat melihat status (tercantum di bawah Duration ) dan ekor file log. Setelah berhasil diselesaikan, Anda akan melihat 2 file baru yang terdaftar di bawah Kumpulan data dalam daftar Aset.

    CATATAN: File data yang dibuat (target dan fitur) akan memiliki tag versi yang ditambahkan ke namanya. Ini cocok dengan argumen baris perintah yang kami berikan ke dalam skrip.

    Jalankan secara interaktif dari editor skrip

    • dari halaman proyek, klik Skrip di daftar Aset, lalu klik skrip feature_engineering dalam daftar. Ini akan memunculkan editor skrip.

    Klik tombol Jalankan konfigurasi di bilah alat lalu tambahkan v1 sebagai argumen baris perintah.

    Seret ikon ukuran yang terletak di sisi kanan panel untuk membuka log konsol. Kemudian mulai skrip dengan mengklik tombol Run -> Run as job di bilah alat.

    Script akan mulai mengeksekusi dan menampilkan output ke log konsol.

    Menggunakan salah satu metode, ulangi proses ini untuk menjalankan skrip model_scoring, lalu skrip extract_and_score.

    CATATAN: Skrip extract_and_score akan gagal saat mencoba memeriksa status skrip model_scoring. Ingat, itu memanggil skrip lain dengan memanggil titik akhir mereka yang digunakan di Watson Machine Learning. Masalahnya adalah skrip yang digunakan tersebut belum memiliki informasi titik akhir yang diperbarui, dan tidak akan sampai kami mendorong perubahan kami kembali ke model rilis Watson Machine Learning (yang akan kami lakukan selanjutnya).

    Setelah Anda memverifikasi skrip, komit dan dorong perubahan ke Watson Studio Master Repository, seperti dijelaskan di atas pada Langkah #5. Pastikan Anda menabrak nomor versi.

    13. Kelola model Anda dengan IBM Watson Machine Learning

    Luncurkan IBM Watson Machine Learning dengan memilihnya dari menu drop-down utama di halaman beranda Watson Studio Local.

    Pertama, kami perlu memperbarui proyek rilis kami untuk mengambil semua versi terbaru dari skrip kami.

    Dari halaman beranda Watson Machine Learning, klik ubin proyek kami.

    Dari deretan ikon yang tercantum di spanduk halaman, klik ikon Perbarui.

    Dari layar pembaruan, gunakan menu tarik-turun proyek Sumber untuk memilih proyek Watson Studio Lokal kami. Kemudian pilih tag versi yang terkait dengan komit terbaru kami.

    Sekarang setelah semua aset kami diperbarui, kami benar-benar dapat mengelola model kami dengan melacak penggunaan dan kinerjanya.

    Untuk memulai, mari kita mulai dengan menjalankan skrip extract_and_score kita. Seperti yang dijelaskan sebelumnya, ini akan membaca file csv wine saat ini dan mengubahnya, lalu menilai setiap wine terhadap model kita.

    • Dari halaman Aset, pilih skrip extract_and_score. Dari halaman detail, klik nama skrip untuk membuka halaman peluncuran skrip. Kemudian klik pada tab API.

    Perhatikan bahwa nilai argumen baris perintah diatur ke v1 . Anda dapat mengatur ini ke apa pun yang Anda inginkan, tetapi itu akan ditambahkan ke nama file yang dihasilkan oleh skrip ini. Ini adalah cara untuk menghindari menimpa data dari menjalankan skrip ini sebelumnya.

    Untuk menjalankan skrip, klik tab Ikhtisar dan gulir ke bawah ke bagian Jalankan halaman. Kemudian klik tombol jalankan sekarang.

    Dari dialog mulai, masukkan nama, ubah argumen baris perintah jika diperlukan, lalu klik tombol Jalankan.

    Anda dapat melihat status pekerjaan dari panel yang sama. Untuk melihat file log terkait, klik opsi menu Lihat log yang terletak di sisi kanan baris pekerjaan.

    Dari dasbor utama, Anda juga dapat melihat bahwa skrip berhasil diselesaikan, dan juga perhatikan bahwa dalam kasus skrip ekstrak dan skor, tiga pekerjaan terpisah diluncurkan (skrip utama, dan dua skrip yang dipanggil).

    Jika skrip berhasil diselesaikan, harus ada tiga file data berversi yang harus ditambahkan sebagai aset kumpulan data dalam proyek. File scoring_output-v1 berisi skor klasifikasi anggur akhir.

    Berikut adalah tautan ke masing-masing buku catatan dengan contoh keluaran:

    • Pola Kode Analisis Data: Suka dengan Pola Kode ini? Lihat Pola Kode Analisis Data kami yang lain
    • Daftar Putar Pola AI dan Kode Data: Tandai daftar putar kami dengan semua video Pola Kode kami
    • Watson Studio: Kuasai seni ilmu data dengan IBM Watson Studio
    • Spark di IBM Cloud: Butuh kluster Spark? Buat hingga 30 pelaksana Spark di IBM Cloud dengan layanan Spark kami

    Pola kode ini dilisensikan di bawah Lisensi Perangkat Lunak Apache, Versi 2. Objek kode pihak ketiga terpisah yang dipanggil dalam pola kode ini dilisensikan oleh penyedia masing-masing sesuai dengan lisensi terpisah mereka sendiri. Kontribusi tunduk pada Sertifikat Asal Pengembang, Versi 1.1 (DCO) dan Lisensi Perangkat Lunak Apache, Versi 2.


    Keras ImageDataGenerator dan Augmentasi Data

    Pembaruan 06-04 2020: Entri blog ini sekarang kompatibel dengan TensorFlow 2+!

    Kami akan memulai tutorial ini dengan diskusi tentang augmentasi data dan mengapa kami menggunakannya.

    Saya kemudian akan membahas tiga jenis augmentasi data yang akan Anda lihat saat melatih jaringan saraf dalam:

    1. Pembuatan kumpulan data dan perluasan data melalui augmentasi data (kurang umum)
    2. Augmentasi data di tempat/on-the-fly (paling umum)
    3. Menggabungkan pembuatan set data dan augmentasi di tempat

    Dari sana saya akan mengajari Anda cara menerapkan augmentasi data ke kumpulan data Anda sendiri (menggunakan ketiga metode tersebut) menggunakan kelas ImageDataGenerator Keras.

    Apa itu augmentasi data?

    Augmentasi data mencakup berbagai teknik yang digunakan untuk menghasilkan sampel pelatihan "baru" dari yang asli dengan menerapkan kegugupan dan gangguan acak (tetapi pada saat yang sama memastikan bahwa label kelas data tidak berubah).

    Tujuan kami ketika menerapkan augmentasi data adalah untuk meningkatkan generalisasi model.

    Mengingat bahwa jaringan kami terus-menerus melihat versi data input baru yang sedikit dimodifikasi, jaringan dapat mempelajari fitur yang lebih kuat.

    Pada waktu pengujian kami tidak menerapkan augmentasi data dan hanya mengevaluasi jaringan terlatih kami pada data pengujian yang tidak dimodifikasi — dalam banyak kasus, Anda akan melihat peningkatan akurasi pengujian, mungkin dengan mengorbankan sedikit penurunan dalam akurasi pelatihan.

    Contoh augmentasi data sederhana

    Gambar 2: Kiri: Sampel 250 titik data yang mengikuti distribusi normal dengan tepat. Baik: Menambahkan sejumlah kecil "jitter" acak ke distribusi. Jenis augmentasi data ini meningkatkan generalisasi jaringan kami.

    Mari kita pertimbangkan Gambar 2 (kiri) dari distribusi normal dengan rata-rata nol dan varians unit.

    Melatih model pembelajaran mesin pada data ini dapat mengakibatkan kita memodelkan distribusi persis — namun, dalam aplikasi dunia nyata, data jarang mengikuti distribusi yang bagus dan rapi.

    Sebagai gantinya, untuk meningkatkan generalisasi dari pengklasifikasi kami, pertama-tama kami dapat secara acak membuat titik-titik di sepanjang distribusi dengan menambahkan beberapa nilai acak diambil dari distribusi acak (Baik).

    Plot kami masih mengikuti sekitar distribusi normal, tetapi bukan a sempurna distribusi seperti di sebelah kiri.

    Model yang dilatih pada data yang dimodifikasi dan ditambah ini lebih cenderung digeneralisasi ke contoh titik data yang tidak termasuk dalam set pelatihan.

    Visi komputer dan augmentasi data

    Gambar 3: Dalam visi komputer, augmentasi data melakukan manipulasi acak pada gambar. Ini biasanya diterapkan dalam tiga skenario yang dibahas dalam posting blog ini.

    Dalam konteks visi komputer, augmentasi data cocok secara alami.

    Misalnya, kita dapat memperoleh data yang diperbesar dari gambar asli dengan menerapkan transformasi geometris sederhana, seperti acak:

    1. Terjemahan
    2. Rotasi
    3. Perubahan skala
    4. Pencukuran
    5. Horizontal (dan dalam beberapa kasus, vertikal) membalik

    Menerapkan sejumlah (kecil) transformasi ke gambar input akan sedikit mengubah tampilannya, tetapi itu tidak ubah label kelas — sehingga membuat augmentasi data menjadi metode yang sangat alami dan mudah untuk diterapkan pada tugas visi komputer.

    Tiga jenis augmentasi data

    Ada tiga jenis augmentasi data yang kemungkinan besar akan Anda temui saat menerapkan pembelajaran mendalam dalam konteks aplikasi visi komputer.

    Definisi augmentasi data yang "benar" adalah sepenuhnya tergantung pada konteks proyek/set eksperimen Anda.

    Luangkan waktu untuk membaca bagian ini hati-hati as I see many deep learning practitioners confuse what data augmentation does and does not do.

    Type #1: Dataset generation and expanding an existing dataset (less common)

    Figure 4: Type #1 of data augmentation consists of dataset generation/dataset expansion. This is a less common form of data augmentation.

    The first type of data augmentation is what I call dataset generation atau dataset expansion.

    As you know machine learning models, and especially neural networks, can require quite a bit of training data — but what if you don’t have very much training data in the first place?

    Let’s examine the most trivial case where you only have one image and you want to apply data augmentation to create an entire dataset of images, all based on that one image.

    To accomplish this task, you would:

    1. Load the original input image from disk.
    2. Randomly transform the original image via a series of random translations, rotations, etc.
    3. Take the transformed image and write it back out to disk.
    4. Repeat steps 2 and 3 a total of N times.

    After performing this process you would have a directory full of randomly transformed “new” images that you could use for training, all based on that single input image.

    This is, of course, an incredibly simplified example.

    You more than likely have more than a single image — you probably have 10s or 100s of images and now your goal is to turn that smaller set into 1000s of images for training.

    In those situations, dataset expansion and dataset generation may be worth exploring.

    But there’s a problem with this approach — we haven’t exactly increased the ability of our model to generalize.

    Yes, we have increased our training data by generating additional examples, but all of these examples are based on a super small dataset.

    Keep in mind that our neural network is only as good as the data it was trained on.

    We cannot expect to train a NN on a small amount of data and then expect it to generalize to data it was never trained on and has never seen before.

    If you find yourself seriously considering dataset generation and dataset expansion, you should take a step back and instead invest your time gathering additional data or looking into methods of behavioral cloning (and then applying the type of data augmentation covered in the “Combining dataset generation and in-place augmentation” section below).

    Type #2: In-place/on-the-fly data augmentation (most common)

    Figure 5: Type #2 of data augmentation consists of on-the-fly image batch manipulations. This is the most common form of data augmentation with Keras.

    The second type of data augmentation is called in-place data augmentation atau on-the-fly data augmentation. This type of data augmentation is what Keras’ ImageDataGenerator class implements.

    Using this type of data augmentation we want to ensure that our network, when trained, sees new variations of our data at each and every epoch.

    Figure 5 demonstrates the process of applying in-place data augmentation:

    1. Step #1: An input batch of images is presented to the ImageDataGenerator .
    2. Step #2: The ImageDataGenerator transforms each image in the batch by a series of random translations, rotations, etc.
    3. Step #3: The randomly transformed batch is then returned to the calling function.

    There are two important points that I want to draw your attention to:

    1. The ImageDataGenerator is not returning both the original data and the transformed data — the class only returns the randomly transformed data.
    2. We call this “in-place” and “on-the-fly” data augmentation because this augmentation is done at training time (i.e., we are not generating these examples ahead of time/prior to training).

    When our model is being trained, we can think of our ImageDataGenerator class as “intercepting” the original data, randomly transforming it, and then returning it to the neural network for training, all the while the NN has no idea the data was modified!

    I’ve written previous tutorials on the PyImageSearch blog where readers think that Keras’ ImageDateGenerator class is an “additive operation”, similar to the following (incorrect) figure:

    Figure 6: How Keras data augmentation does not work.

    In the above illustration the ImageDataGenerator accepts an input batch of images, randomly transforms the batch, and then returns both the original batch and modified data — again, this is not what the Keras ImageDataGenerator does. Instead, the ImageDataGenerator class will return just the randomly transformed data.

    When I explain this concept to readers the next question is often:

    But Adrian, what about the original training data? Why is it not used? Isn’t the original training data still useful for training?

    Keep in mind that the entire point of the data augmentation technique described in this section is to ensure that the network sees “new” images that it has never “seen” before at each and every epoch.

    If we included the original training data along with the augmented data in each batch, then the network would “see” the original training data multiple times, effectively defeating the purpose. Secondly, recall that the overall goal of data augmentation is to increase the generalizability of the model.

    To accomplish this goal we “replace” the training data with randomly transformed, augmented data.

    In practice, this leads to a model that performs better on our validation/testing data but perhaps performs slightly worse on our training data (to due to the variations in data caused by the random transforms).

    You’ll learn how to use the Keras ImageDataGenerator class later in this tutorial.

    Type #3: Combining dataset generation and in-place augmentation

    The final type of data augmentation seeks to combine kedua dataset generation and in-place augmentation — you may see this type of data augmentation when performing behavioral cloning.

    A great example of behavioral cloning can be seen in self-driving car applications.

    Creating self-driving car datasets can be extremely time consuming and expensive — a way around the issue is to instead use video games and car driving simulators.

    Video game graphics have become so life-like that it’s now possible to use them as training data.

    Therefore, instead of driving an actual vehicle, you can instead:

    • Play a video game
    • Write a program to play a video game
    • Use the underlying rendering engine of the video game

    …all to generate actual data that can be used for training.

    Once you have your training data you can go back and apply Type #2 data augmentation (i.e., in-place/on-the-fly data augmentation) to the data you gathered via your simulation.

    Configuring your development environment

    To configure your system for this tutorial, I first recommend following either of these tutorials:

    Either tutorial will help you configure you system with all the necessary software for this blog post in a convenient Python virtual environment.

    Project structure

    Before we dive into the code let’s first review our directory structure for the project:

    First, there are two dataset directories which are not to be confused:

    • dogs_vs_cats_small/ : A subset of the popular Kaggle Dogs vs. Cats competition dataset. In my curated subset, only 2,000 images (1,000 per class) are present (as opposed to the 25,000 images for the challenge).
    • generated_dataset/ : We’ll create this generated dataset using the cat.jpg and dog.jpg images which are in the parent directory. We’ll utilize data augmentation Type #1 to generate this dataset automatically and fill this directory with images.

    Next, we have our pyimagesearch module which contains our implementation of the ResNet CNN classifier.

    Today, we’ll review two Python scripts:

    • train.py : Used to train models for both Type #1 dan Type #2 (and optionally Type #3 if the user so wishes) data augmentation techniques. We’ll perform three training experiments resulting in each of the three plot*.png files in the project folder.
    • generate_images.py : Used to generate a dataset from a single image using Type #1.

    Implementing our training script

    In the remainder of this tutorial we’ll be performing three experiments:

    1. Experiment #1: Generate a dataset via dataset expansion and train a CNN on it.
    2. Experiment #2: Use a subset of the Kaggle Dogs vs. Cats dataset and train a CNN without data augmentation.
    3. Experiment #3: Repeat the second experiment, but this time with data augmentation.

    All of these experiments will be accomplished using the same Python script.

    Open up the train.py script and let’s get started:

    On Lines 2-18 our necessary packages are imported. Line 10 is our ImageDataGenerator import from the Keras library — a class for data augmentation.

    Our script accepts three command line arguments via the terminal:

    • --dataset : The path to the input dataset.
    • --augment : Whether “on-the-fly” data augmentation should be used (refer to type #2 above). By default, this method is not performed.
    • --plot : The path to the output training history plot.

    Let’s proceed to initialize hyperparameters and load our image data:

    Training hyperparameters, including initial learning rate, batch size, and number of epochs to train for, are initialized on Lines 32-34.

    From there Lines 39-53 grab imagePaths , load images, and populate our data and labels lists. The only image preprocessing we perform at this point is to resize each image to 64吼px.

    Next, let’s finish preprocessing, encode our labels, and partition our data:

    On Line 57, we convert data to a NumPy array as well as scale all pixel intensities to the range [0, 1]. This completes our preprocessing.

    From there we perform “one-hot encoding” of our labels (Lines 61-63). This method of encoding our labels results in an array that may look like this:

    For this sample of data, there are two cats ( [1., 0.] ) and five dogs ( [0., 1] ) where the label corresponding to the image is marked as “hot”.

    From there we partition our data into training and testing splits marking 75% of our data for training and the remaining 25% for testing (Lines 67 and 68).

    Now, we are ready to initialize our data augmentation object:

    Line 71 initializes our empty data augmentation object (i.e., no augmentation will be performed). This is the default operation of this script.

    Let’s check if we’re going to override the default with the --augment command line argument:

    Line 75 checks to see if we are performing data augmentation. If so, we re-initialize the data augmentation object with random transformation parameters (Lines 77-84). As the parameters indicate, random rotations, zooms, shifts, shears, and flips will be performed during in-place/on-the-fly data augmentation.

    Let’s compile and train our model:

    2020-06-04 Update: Formerly, TensorFlow/Keras required use of a method called .fit_generator in order to accomplish data augmentation. Now, the .fit method can handle data augmentation as well, making for more-consistent code. This also applies to the migration from .predict_generator to .predict . Be sure to check out my other article fit and fit_generator after you’re done reading this tutorial.

    Lines 88-92 construct our ResNet model using Stochastic Gradient Descent optimization and learning rate decay. We use "binary_crossentropy" loss for this 2-class problem. If you have more than two classes, be sure to use "categorial_crossentropy" .

    Lines 96-100 then train our model. The aug object handles data augmentation in batches (although be sure to recall that the aug object will only perform data augmentation if the --augment command line argument was set).

    Finally, we’ll evaluate our model, print statistics, and generate a training history plot:

    2020-06-04 Update: In order for this plotting snippet to be TensorFlow 2+ compatible the H.history dictionary keys are updated to fully spell out “accuracy” sans “acc” (i.e., H.history["val_accuracy"] and H.history["accuracy"] ). It is semi-confusing that “val” is not spelled out as “validation” we have to learn to love and live with the API and always remember that it is a work in progress that many developers around the world contribute to.

    Line 104 makes predictions on the test set for evaluation purposes. A classification report is printed via Lines 105 and 106.

    From there, Lines 109-120 generate and save an accuracy/loss training plot.

    Generating a dataset/dataset expansion with data augmentation and Keras

    In our first experiment, we will perform dataset expansion via data augmentation with Keras.

    Our dataset will contain 2 classes and initially, the dataset will trivially contain only 1 image per class:

    We’ll utilize Type #1 data augmentation (see the “Type #1: Dataset generation and expanding an existing dataset” section above) to generate a new dataset with 100 images per class:

    Again, this meant to be an example — in a real-world application you would have 100s of example images, but we’re keeping it simple here so you can learn the concept.

    Generating the example dataset

    Before we can train our CNN we first need to generate an example dataset.

    From our “Project Structure” section above you know that we have two example images in our root directory: cat.jpg and dog.jpg . We will use these example images to generate 100 new training images per class (200 images in total).

    To see how we can use data augmentation to generate new examples, open up the generate_images.py file and follow along:

    Lines 2-6 import our necessary packages. Our ImageDataGenerator is imported on Line 2 and will handle our data augmentation with Keras.

    From there, we’ll parse three command line arguments:

    • --image : The path to the input image. We’ll generate additional random, mutated versions of this image.
    • --output : The path to the output directory to store the data augmentation examples.
    • --total : The number of sample images to generate.

    Let’s go ahead and load our image and initialize our data augmentation object:

    Our image is loaded and prepared for data augmentation via Lines 21-23. Image loading and processing is handled via Keras functionality (i.e. we aren’t using OpenCV).

    From there, we initialize the ImageDataGenerator object. This object will facilitate performing random rotations, zooms, shifts, shears, and flips on our input image.

    Next, we’ll construct a Python generator and put it to work until all of our images have been produced:

    We will use the imageGen to randomly transform the input image (Lines 39 and 40). This generator saves images as .jpg files to the specified output directory contained within args["output"] .

    Finally, we’ll loop over examples from our image data generator and count them until we’ve reached the required total number of images.

    To run the generate_examples.py script make sure you have used the “Downloads” section of the tutorial to download the source code and example images.

    From there open up a terminal and execute the following command:

    Check the output of the generated_dataset/cats directory you will now see 100 images:

    Let’s do the same now for the “dogs” class:

    And now check for the dog images:

    A visualization of the dataset generation via data augmentation can be seen in Figure 6 at the top of this section — notice how we have accepted a single input image (of me — not of a dog or cat) and then created 100 new training examples (48 of which are visualized) from that single image.

    Experiment #1: Dataset generation results

    We are now ready to perform our first experiment:

    Figure 8: Data augmentation with Keras Experiment #1 training accuracy/loss results.

    Our results show that we were able to obtain 100% accuracy with little effort.

    Of course, this is a trivial, contrived example. In practice, you would not be taking only a single image and then building a dataset of 100s or 1000s of images via data augmentation. Instead, you would have a dataset of 100s of images and then you would apply dataset generation to that dataset — but again, the point of this section was to demonstrate on a simple example so you could understand the process.

    Training a network with in-place data augmentation

    The more popular form of (image-based) data augmentation is called in-place data augmentation (see the “Type #2: In-place/on-the-fly data augmentation” section of this post for more details).

    When performing in-place augmentation our Keras ImageDataGenerator will:

    1. Accept a batch of input images.
    2. Randomly transform the input batch.
    3. Return the transformed batch to the network for training.

    We’ll explore how data augmentation can reduce overfitting and increase the ability of our model to generalize via two experiments.

    To accomplish this task we’ll be using a subset of the Kaggle Dogs vs. Cats dataset:

    We’ll then train a variation of ResNet, from scratch, on this dataset with and without data augmentation.

    Experiment #2: Obtaining a baseline (no data augmentation)

    In our first experiment we’ll perform no data augmentation:

    Looking at the raw classification report you’ll see that we’re obtaining 64% accuracybut there’s a problem!

    Take a look at the plot associated with our training:

    Figure 9: For Experiment #2 we did not perform data augmentation. The result is a plot with strong indications of overfitting.

    There is dramatic overfitting occurring — at approximately epoch 15 we see our validation loss start to rise while training loss continues to fall. By epoch 20 the rise in validation loss is especially pronounced.

    This type of behavior is indicative of overfitting.

    The solution is to (1) reduce model capacity, and/or (2) perform regularization.

    Experiment #3: Improving our results (with data augmentation)

    Let’s now investigate how data augmentation can act as a form of regularization:

    We’re now up to 69% accuracy, an increase from our previous 64% accuracy.

    But more importantly, we are no longer overfitting:

    Figure 10: For Experiment #3, we performed data augmentation with Keras on batches of images in-place. Our training plot shows no signs of overfitting with this form of regularization.

    Note how validation and training loss are falling together with little divergence. Similarly, classification accuracy for both the training and validation splits are growing together as well.

    By using data augmentation we were able to combat overfitting!

    In nearly all situations, unless you have very good reason not to, you should be performing data augmentation when training your own neural networks.

    What's next? I recommend PyImageSearch University.

    I strongly believe that if you had the right teacher you could master computer vision and deep learning.

    Do you think learning computer vision and deep learning has to be time-consuming, overwhelming, and complicated? Or has to involve complex mathematics and equations? Or requires a degree in computer science?

    All you need to master computer vision and deep learning is for someone to explain things to you in simple, intuitive terms. And that’s exactly what I do. My mission is to change education and how complex Artificial Intelligence topics are taught.

    If you're serious about learning computer vision, your next stop should be PyImageSearch University, the most comprehensive computer vision, deep learning, and OpenCV course online today. Here you’ll learn how to successfully dan confidently apply computer vision to your work, research, and projects. Join me in computer vision mastery.

    Inside PyImageSearch University you'll find:

    • &check 23 courses on essential computer vision, deep learning, and OpenCV topics
    • &check 23 Certificates of Completion
    • &check 35h 14m on-demand video
    • &check Brand new courses released every month, ensuring you can keep up with state-of-the-art techniques
    • &check Pre-configured Jupyter Notebooks in Google Colab
    • &check Run all code examples in your web browser — works on Windows, macOS, and Linux (no dev environment configuration required!)
    • &check Access to centralized code repos for all 400+ tutorials on PyImageSearch
    • &check Easy one-click downloads for code, datasets, pre-trained models, etc.
    • &check Access on mobile, laptop, desktop, etc.

    How to Use a Learned Embedding for Categorical Data

    A learned embedding, or simply an “embedding,” is a distributed representation for categorical data.

    Each category is mapped to a distinct vector, and the properties of the vector are adapted or learned while training a neural network. The vector space provides a projection of the categories, allowing those categories that are close or related to cluster together naturally.

    This provides both the benefits of an ordinal relationship by allowing any such relationships to be learned from data, and a one hot encoding in providing a vector representation for each category. Unlike one hot encoding, the input vectors are not sparse (do not have lots of zeros). The downside is that it requires learning as part of the model and the creation of many more input variables (columns).

    The technique was originally developed to provide a distributed representation for words, e.g. allowing similar words to have similar vector representations. As such, the technique is often referred to as a word embedding, and in the case of text data, algorithms have been developed to learn a representation independent of a neural network. For more on this topic, see the post:

    An additional benefit of using an embedding is that the learned vectors that each category is mapped to can be fit in a model that has modest skill, but the vectors can be extracted and used generally as input for the category on a range of different models and applications. That is, they can be learned and reused.

    Embeddings can be used in Keras via the Embedding layer.

    For an example of learning word embeddings for text data in Keras, see the post:

    One embedding layer is required for each categorical variable, and the embedding expects the categories to be ordinal encoded, although no relationship between the categories is assumed.

    Each embedding also requires the number of dimensions to use for the distributed representation (vector space). It is common in natural language applications to use 50, 100, or 300 dimensions. For our small example, we will fix the number of dimensions at 10, but this is arbitrary you should experimenter with other values.

    First, we can prepare the input data using an ordinal encoding.

    The model we will develop will have one separate embedding for each input variable. Therefore, the model will take nine different input datasets. As such, we will split the input variables and ordinal encode (integer encoding) each separately using the LabelEncoder and return a list of separate prepared train and test input datasets.

    Itu prepare_inputs() function below implements this, enumerating over each input variable, integer encoding each correctly using best practices, and returning lists of encoded train and test variables (or one-variable datasets) that can be used as input for our model later.

    Now we can construct the model.

    We must construct the model differently in this case because we will have nine input layers, with nine embeddings the outputs of which (the nine different 10-element vectors) need to be concatenated into one long vector before being passed as input to the dense layers.

    We can achieve this using the functional Keras API. If you are new to the Keras functional API, see the post:

    First, we can enumerate each variable and construct an input layer and connect it to an embedding layer, and store both layers in lists. We need a reference to all of the input layers when defining the model, and we need a reference to each embedding layer to concentrate them with a merge layer.

    We can then merge all of the embedding layers, define the hidden layer and output layer, then define the model.

    When using a model with multiple inputs, we will need to specify a list that has one dataset for each input, e.g. a list of nine arrays each with one column in the case of our dataset. Thankfully, this is the format we returned from our prepare_inputs() function.

    Therefore, fitting and evaluating the model looks like it does in the previous section.

    Additionally, we will plot the model by calling the plot_model() function and save it to file. This requires that pygraphviz and pydot are installed, which can be a pain on some systems. If you have trouble, just comment out the import statement and call to plot_model().

    Tying this all together, the complete example of using a separate embedding for each categorical input variable in a multi-input layer model is listed below.

    Running the example prepares the data as described above, fits the model, and reports the performance.

    Note: Your results may vary given the stochastic nature of the algorithm or evaluation procedure, or differences in numerical precision. Consider running the example a few times and compare the average outcome.

    In this case, the model performs reasonably well, matching what we saw for the one hot encoding in the previous section.

    As the learned vectors were trained in a skilled model, it is possible to save them and use them as a general representation for these variables in other models that operate on the same data. A useful and compelling reason to explore this encoding.

    To confirm our understanding of the model, a plot is created and saved to the file embeddings.png in the current working directory.

    The plot shows the nine inputs each mapped to a 10 element vector, meaning that the actual input to the model is a 90 element vector.

    Note: Click to the image to see the large version.

    Plot of the Model Architecture With Separate Inputs and Embeddings for each Categorical Variable
    Click to Enlarge.


    X_train, y_train = train_generator.next() X_test, y_test = validation_generator.next()

    X_train, y_train = next(train_generator) X_test, y_test = next(validation_generator)

    As per the above answer, the below code just gives 1 batch of data.

    To extract full data from the train_generator use below code -

    y_train, y_test values will be based on the category folders you have in train_data_dir. Not values will be like 0,1,2,3. mapping to class names in Alphabetical Order.

    Otherwise, use below code to get indices map

    Make sure they both are the same.

    More of an indirect answer, but maybe helpful to some: Here is a script I use to sort test and train images into the respective (sub) folders to work with Keras and the data generator function (MS Windows).


    Summary

    In this tutorial, you learned how to use the Keras deep learning library for regression.

    Specifically, we used Keras and regression to predict the price of houses based on four numerical and categorical attributes:

    • Number of bedrooms
    • Number of bathrooms
    • Area (i.e., square footage)
    • Zip code

    Overall our neural network obtained a mean absolute percentage error of 22.71%, implying that, on average, our house price predictions will be off by 22.71%.

    That raises the questions:

    • How can we better our house price prediction accuracy?
    • What if we leveraged images for each house? Would that improve accuracy?
    • Is there some way to combine both our categorical/numerical attributes with our image data?

    To answer these questions you’ll need to stay tuned for the remaining to tutorials in this Keras regression series.

    To download the source code to this post (and be notified when the next tutorial is published here on PyImageSearch), just enter your email address in the form below.

    Download the Source Code and FREE 17-page Resource Guide

    Enter your email address below to get a .zip of the code and a FREE 17-page Resource Guide on Computer Vision, OpenCV, and Deep Learning. Inside you'll find my hand-picked tutorials, books, courses, and libraries to help you master CV and DL!

    About the Author

    Hi there, I’m Adrian Rosebrock, PhD. All too often I see developers, students, and researchers wasting their time, studying the wrong things, and generally struggling to get started with Computer Vision, Deep Learning, and OpenCV. I created this website to show you what I believe is the best possible way to get your start.


    Making your model impactful

    Tada! We’ve now made our lead scoring model impactful by sending results directly into Intercom. To get a sense of how this might show up for a sales team member, here you can see each example lead now has a custom attribute listing whether or not they are likely to convert:

    With these labels easily available for each potential lead, a sales team member can start to prioritize their time and pick who they will reach out to first. This will hopefully lead to better efficiency, and more sales for your business! There are many ways to measure the success of these outcomes, but we’ll visit that at another time!


    Tonton videonya: SERob3 python Դաս #2 - Լեդ լույսերի աշխատանքի պարզագույն օրինակ python - ի միջոցով (Oktober 2021).