Halo semuanya!
Peluncuran kursus
"Pengembang web dengan Python" semakin dekat, masing-masing, kami masih berbagi artikel menarik dan mengundang kami ke pelajaran terbuka kami, di mana Anda dapat menonton materi yang menarik, bertemu
guru, dan mengajukan pertanyaan kepada mereka.
Ayo pergi!
HDF5 memungkinkan penyimpanan data dalam jumlah besar secara efisienKetika bekerja dengan volume data yang besar, baik eksperimental atau disimulasikan, menyimpannya dalam beberapa file teks tidak terlalu efisien. Terkadang Anda perlu mengakses bagian data tertentu, dan Anda ingin melakukannya dengan cepat. Dalam situasi ini, format HDF5 menyelesaikan kedua masalah berkat perpustakaan bawaan yang sangat dioptimalkan. HDF5 banyak digunakan dalam lingkungan ilmiah dan memiliki implementasi yang sangat baik dalam Python yang dirancang untuk bekerja dengan NumPy.
Format HDF5 mendukung file dalam ukuran apa pun, dan setiap file memiliki struktur internal yang memungkinkan Anda untuk mencari kumpulan data tertentu. Ini dapat dianggap sebagai file terpisah dengan struktur hierarkisnya sendiri, serta seperangkat folder dan subfolder. Secara default, data disimpan dalam format biner, dan perpustakaan kompatibel dengan berbagai jenis data. Salah satu opsi paling penting untuk format HDF5 adalah ia memungkinkan Anda untuk melampirkan metadata ke setiap elemen struktur, membuatnya ideal untuk membuat file offline.
Dalam Python, antarmuka dengan format HDF5 dapat dibangun menggunakan paket h5py. Salah satu fitur paling menarik dari paket ini adalah bahwa data dibaca dari file hanya jika diperlukan. Bayangkan Anda memiliki array yang sangat besar yang tidak sesuai dengan RAM yang tersedia. Misalnya, Anda bisa membuat array di komputer dengan spesifikasi berbeda, tidak seperti yang Anda gunakan untuk analisis data. Format HDF5 memungkinkan Anda memilih elemen array mana yang akan dibaca dengan sintaks yang setara dengan NumPy. Kemudian Anda dapat bekerja dengan data yang disimpan di hard drive, dan bukan di RAM, tanpa perubahan signifikan pada kode yang ada.
Pada artikel ini, kita akan melihat bagaimana Anda dapat menggunakan h5py untuk menyimpan dan mengambil data dari hard drive Anda. Kami akan membahas berbagai cara menyimpan data dan cara mengoptimalkan proses membaca. Semua contoh yang muncul dalam artikel ini juga tersedia di
repositori Github kami.
InstalasiFormat HDF5 didukung oleh
Grup HDF , dan didasarkan pada standar open source, yang berarti bahwa data Anda akan selalu tersedia, bahkan jika grup tersebut menghilang. Dukungan python disediakan melalui paket
h5py , yang dapat diinstal melalui pip. Ingat bahwa Anda harus menggunakan lingkungan
virtual untuk pengujian:
pip install h5py
perintah ini juga akan menginstal NumPy jika tidak di lingkungan Anda.
Jika Anda mencari alat grafis untuk memeriksa konten file HDF5 Anda, Anda dapat menginstal
HDF5 Viewer . Itu ditulis dalam Java, jadi itu harus bekerja di hampir semua komputer.
Penyimpanan dan pembacaan data dasarMari kita beralih ke menggunakan perpustakaan HDF5. Kami akan membuat file baru dan menyimpan array NumPy acak ke dalamnya.
import h5py import numpy as np arr = np.random.randn(1000) with h5py.File('random.hdf5', 'w') as f: dset = f.create_dataset("default", data=arr)
Beberapa baris pertama cukup sederhana: kita mengimpor paket h5py dan NumPy dan membuat array dengan nilai acak. Kami membuka file random.hdf5 dengan izin tulis, yang berarti bahwa jika file dengan nama yang sama sudah ada, file itu akan ditimpa. Jika Anda ingin menyimpan file dan masih bisa menulis ke sana, Anda dapat membukanya dengan atribut bukan w. Kami membuat dataset yang disebut default dan mengatur data sebagai array acak yang dibuat sebelumnya. Kumpulan data adalah pemelihara data kami, terutama blok bangunan format HDF5.
Sebuah catatan
Jika Anda tidak terbiasa dengan pernyataan with, saya harus mencatat bahwa ini adalah cara yang mudah untuk membuka dan menutup file. Bahkan jika kesalahan terjadi di dalam
with , file akan ditutup. Jika karena alasan tertentu Anda tidak menggunakannya, jangan pernah lupa menambahkan perintah
f.close() di akhir. Pernyataan
with berfungsi dengan file apa pun, bukan hanya file HDF.
Kita dapat membaca data dengan cara yang hampir sama dengan membaca file NumPy:
with h5py.File('random.hdf5', 'r') as f: data = f['default'] print(min(data)) print(max(data)) print(data[:15])
Kami membuka file dengan atribut read r dan mengembalikan data dengan secara langsung mengakses set data yang disebut default. Jika Anda membuka file dan tidak tahu set data mana yang tersedia, Anda bisa mendapatkannya:
for key in f.keys(): print(key)
Setelah Anda membaca dataset yang Anda inginkan, Anda bisa menggunakannya seolah-olah Anda menggunakan array NumPy apa pun. Misalnya, Anda dapat menemukan nilai maksimum dan minimum atau memilih 15 nilai pertama array. Contoh-contoh sederhana ini, bagaimanapun, menyembunyikan banyak hal yang terjadi di bawah tenda, dan mereka perlu didiskusikan untuk memahami potensi penuh HDF5.
Dalam contoh di atas, Anda bisa menggunakan data sebagai array. Misalnya, Anda bisa merujuk ke elemen ketiga dengan memasukkan data [2], atau Anda bisa mendapatkan rentang nilai data [1: 3]. Harap dicatat: data bukan sebuah array, ini adalah kumpulan data. Anda bisa melihatnya dengan mengetik
print(type(data)) . Kumpulan data bekerja dengan cara yang sama sekali berbeda dari array, karena informasinya disimpan di hard drive, dan mereka tidak memuatnya ke dalam RAM jika kita tidak menggunakannya. Kode berikut, misalnya, tidak akan berfungsi:
f = h5py.File('random.hdf5', 'r') data = f['default'] f.close() print(data[1])
Kesalahan yang muncul sedikit rumit, tetapi baris terakhir sangat berguna:
ValueError: Not a dataset (not a dataset)
Kesalahan tersebut berarti bahwa kami mencoba mengakses dataset yang tidak lagi dapat kami akses. Ini agak membingungkan, tetapi itu terjadi karena kami menutup file dan oleh karena itu kami tidak lagi diizinkan untuk mengakses nilai kedua dalam data. Ketika kami menetapkan f ['default'] untuk data variabel, kami sebenarnya tidak membaca data dari file, sebaliknya kami membuat pointer ke tempat data berada di hard drive. Di sisi lain, kode ini akan berfungsi:
f = h5py.File('random.hdf5', 'r') data = f['default'][:] f.close() print(data[10])
Harap dicatat bahwa satu-satunya perbedaan adalah bahwa kami menambahkan [:] setelah membaca dataset. Banyak manual lain berkutat pada contoh-contoh seperti itu, bahkan tanpa menunjukkan potensi penuh format HDF5 dengan paket h5py. Karena contoh yang telah kami periksa sejauh ini, Anda mungkin bertanya-tanya: mengapa menggunakan HDF5 jika menyimpan file NumPy memberi Anda fungsi yang sama? Mari selami fitur-fitur format HDF5.
Pembacaan selektif dari file HDF5Sejauh ini, kita telah melihat bahwa ketika kita membaca kumpulan data, kita belum membaca data dari disk, sebaliknya kita membuat tautan ke tempat tertentu pada hard disk. Kita dapat melihat apa yang terjadi jika, misalnya, kita secara eksplisit membaca 10 elemen pertama dari kumpulan data:
with h5py.File('random.hdf5', 'r') as f: data_set = f['default'] data = data_set[:10] print(data[1]) print(data_set[1])
Kami membagi kode menjadi baris yang berbeda untuk membuatnya lebih eksplisit, tetapi Anda bisa lebih sintetis dalam proyek Anda. Pada baris di atas, pertama-tama kita membaca file dan kemudian membaca dataset default. Kami menetapkan 10 elemen pertama dari set data ke variabel data. Setelah menutup file (saat berakhir), kita dapat mengakses nilai yang disimpan dalam data, tetapi data_set akan menimbulkan kesalahan. Perhatikan bahwa kita hanya membaca dari disk ketika kita secara eksplisit mengakses 10 elemen pertama dari kumpulan data. Jika Anda melihat tipe data dan tipe data, Anda akan melihat bahwa mereka sangat berbeda. Yang pertama adalah array NumPy, dan yang kedua adalah h5py DataSet.
Perilaku yang sama relevan dalam skenario yang lebih kompleks. Mari kita buat file baru, kali ini dengan dua set data, dan mari kita pilih elemen salah satunya berdasarkan elemen yang lain. Mari kita mulai dengan membuat file baru dan menyimpan data; bagian ini adalah yang paling sederhana:
import h5py import numpy as np arr1 = np.random.randn(10000) arr2 = np.random.randn(10000) with h5py.File('complex_read.hdf5', 'w') as f: f.create_dataset('array_1', data=arr1) f.create_dataset('array_2', data=arr2)
Kami memiliki dua dataset yang disebut array_1 dan array_2, yang masing-masing berisi array NumPy acak. Kami ingin membaca nilai array_2 yang sesuai dengan elemen di mana nilai array_1 positif. Kita dapat mencoba melakukan sesuatu seperti ini:
with h5py.File('complex_read.hdf5', 'r') as f: d1 = f['array_1'] d2 = f['array_2'] data = d2[d1>0]
tapi itu tidak akan berhasil. d1 adalah kumpulan data dan tidak dapat dibandingkan dengan integer. Satu-satunya cara adalah dengan benar-benar membaca data dari disk, dan kemudian membandingkannya. Karena itu, kami mendapatkan sesuatu seperti ini:
with h5py.File('complex_read.hdf5', 'r') as f: d1 = f['array_1'] d2 = f['array_2'] data = d2[d1[:]>0]
Kumpulan data pertama d1 sepenuhnya dimuat ke dalam memori saat kita melakukan d1 [:], tetapi dari kumpulan data kedua d2 kita hanya mengambil beberapa elemen. Jika dataset d1 terlalu besar untuk dimuat ke dalam memori sepenuhnya, kita bisa bekerja di dalam satu loop.
with h5py.File('complex_read.hdf5', 'r') as f: d1 = f['array_1'] d2 = f['array_2'] data = [] for i in range(len(d1)): if d1[i] > 0: data.append(d2[i]) print('The length of data with a for loop: {}'.format(len(data)))
Tentu saja, ada masalah dengan efisiensi membaca itemwise dan menambahkan item ke daftar, tetapi ini adalah contoh yang sangat baik dari salah satu keuntungan terbesar menggunakan HDF5 atas teks atau file NumPy. Di dalam loop, kami hanya memuat satu elemen ke dalam memori. Dalam contoh kami, setiap elemen hanyalah angka, tetapi bisa berupa apa saja: dari teks ke gambar atau video.
Seperti biasa, tergantung pada aplikasi Anda, Anda harus memutuskan apakah Anda ingin membaca seluruh array ke dalam memori atau tidak. Kadang-kadang Anda menjalankan simulasi pada komputer tertentu dengan jumlah memori yang besar, tetapi Anda tidak memiliki karakteristik yang sama pada laptop Anda, dan Anda dipaksa untuk membaca bagian data Anda. Ingat bahwa membaca dari hard drive relatif lambat, terutama jika Anda menggunakan HDD, bukan disk SDD atau bahkan lebih lama jika Anda membaca dari drive jaringan.
Secara selektif menulis ke file HDF5Dalam contoh di atas, kami menambahkan data ke dataset segera setelah itu dibuat. Namun, untuk banyak aplikasi Anda perlu menyimpan data selama pembuatan. HDF5 memungkinkan Anda menyimpan data dengan cara yang sama seperti saat Anda membacanya. Mari kita lihat cara membuat dataset kosong dan menambahkan beberapa data ke dalamnya.
arr = np.random.randn(100) with h5py.File('random.hdf5', 'w') as f: dset = f.create_dataset("default", (1000,)) dset[10:20] = arr[50:60]
Dua baris pertama sama dengan sebelumnya, kecuali untuk
create_dataset . Kami tidak menambahkan data saat membuatnya, kami hanya membuat set data kosong yang dapat menampung hingga 1000 elemen. Dengan logika yang sama seperti sebelumnya, ketika kita membaca elemen-elemen tertentu dari kumpulan data, kita sebenarnya menulis ke disk hanya ketika kita memberikan nilai pada elemen-elemen tertentu dari variabel dset. Dalam contoh di atas, kami hanya menetapkan nilai ke subset array, dengan indeks dari 10 hingga 19.
PeringatanTidak sepenuhnya benar apa yang Anda tulis ke disk saat Anda menetapkan nilai ke set data. Momen yang tepat tergantung pada beberapa faktor, termasuk keadaan sistem operasi. Jika program ditutup terlalu cepat, itu mungkin terjadi bahwa tidak semuanya akan direkam. Sangat penting untuk selalu menggunakan metode
close() , dan jika Anda menulis secara bertahap, Anda juga dapat menggunakan
flush() untuk memaksa entri. Menggunakan dengan mencegah banyak masalah penulisan.
Jika Anda membaca file dan mencetak 20 nilai pertama dari kumpulan data, Anda akan melihat bahwa semuanya nol, kecuali indeks 10 hingga 19. Ada kesalahan umum yang dapat menyebabkan sakit kepala yang nyata. Kode berikut tidak akan menyimpan apa pun ke disk:
arr = np.random.randn(1000) with h5py.File('random.hdf5', 'w') as f: dset = f.create_dataset("default", (1000,)) dset = arr
Kesalahan ini selalu menyebabkan banyak masalah, karena Anda tidak akan mengerti bahwa Anda tidak menulis apa pun sampai Anda mencoba membaca hasilnya. Masalahnya di sini adalah bahwa Anda tidak menentukan di mana Anda ingin menyimpan data, Anda hanya menimpa variabel dset dengan array NumPy. Karena dataset dan array memiliki panjang yang sama, Anda harus menggunakan dset [:] = arr. Kesalahan ini terjadi lebih sering daripada yang Anda pikirkan, dan karena secara teknis tidak salah, Anda tidak akan melihat kesalahan yang ditampilkan pada terminal, dan data Anda akan nol.
Sampai sekarang, kami selalu bekerja dengan array satu dimensi, tetapi kami tidak terbatas pada mereka. Sebagai contoh, misalkan kita ingin menggunakan array 2D, kita bisa melakukannya:
dset = f.create_dataset('default', (500, 1024))
yang memungkinkan kita untuk menyimpan data dalam array 500x1024. Untuk menggunakan dataset, kita dapat menggunakan sintaksis yang sama seperti sebelumnya, tetapi dengan mempertimbangkan dimensi kedua:
dset[1,2] = 1 dset[200:500, 500:1024] = 123
Tentukan tipe data untuk mengoptimalkan ruangSejauh ini, kami hanya memeriksa ujung gunung es dari apa yang ditawarkan HDF5. Selain panjang data yang ingin Anda simpan, Anda dapat menentukan tipe data untuk mengoptimalkan ruang.
Dokumentasi h5py berisi daftar semua jenis yang didukung, di sini kami hanya menampilkan beberapa dari mereka. Pada saat yang sama, kami akan bekerja dengan beberapa set data dalam satu file.
with h5py.File('several_datasets.hdf5', 'w') as f: dset_int_1 = f.create_dataset('integers', (10, ), dtype='i1') dset_int_8 = f.create_dataset('integers8', (10, ), dtype='i8') dset_complex = f.create_dataset('complex', (10, ), dtype='c16') dset_int_1[0] = 1200 dset_int_8[0] = 1200.1 dset_complex[0] = 3 + 4j
Dalam contoh di atas, kami membuat tiga set data yang berbeda, masing-masing memiliki tipe yang berbeda. Bilangan bulat 1 byte, bilangan bulat 8 byte, dan bilangan kompleks 16 byte. Kami hanya menyimpan satu nomor, meskipun set data kami dapat berisi hingga 10 elemen. Anda dapat membaca nilai dan melihat apa yang sebenarnya disimpan. Perlu dicatat di sini bahwa bilangan bulat dari 1 byte harus dibulatkan menjadi 127 (bukan 1200), dan bilangan bulat 8 byte harus dibulatkan menjadi 1200 (bukannya 1200.1).
Jika Anda pernah memprogram dalam bahasa seperti C atau Fortran, Anda mungkin tahu apa arti berbagai tipe data. Namun, jika Anda selalu bekerja dengan Python, Anda mungkin tidak mengalami masalah tanpa secara eksplisit menyatakan jenis data yang Anda kerjakan. Penting untuk diingat bahwa jumlah byte memberitahu Anda berapa banyak angka berbeda yang dapat Anda simpan. Jika Anda menggunakan 1 byte, Anda memiliki 8 bit, dan karenanya Anda dapat menyimpan 2 ^ 8 angka yang berbeda. Dalam contoh di atas, bilangan bulat keduanya positif, negatif, dan 0. Ketika Anda menggunakan bilangan bulat dari 1 byte, Anda dapat menyimpan nilai dari -128 hingga 127, totalnya adalah 2 ^ 8 angka yang mungkin. Ini setara dengan menggunakan 8 byte, tetapi dengan berbagai angka.
Jenis data yang dipilih akan memengaruhi ukurannya. Pertama, mari kita lihat bagaimana ini bekerja dengan contoh sederhana. Mari kita membuat tiga file, masing-masing dengan satu set data untuk 100.000 elemen, tetapi dengan tipe data yang berbeda. Kami akan menyimpan data yang sama di dalamnya, dan kemudian membandingkan ukurannya. Kami membuat larik acak untuk penugasan ke setiap set data untuk mengisi memori. Ingat bahwa data akan dikonversi ke format yang ditentukan dalam kumpulan data.
arr = np.random.randn(100000) f = h5py.File('integer_1.hdf5', 'w') d = f.create_dataset('dataset', (100000,), dtype='i1') d[:] = arr f.close() f = h5py.File('integer_8.hdf5', 'w') d = f.create_dataset('dataset', (100000,), dtype='i8') d[:] = arr f.close() f = h5py.File('float.hdf5', 'w') d = f.create_dataset('dataset', (100000,), dtype='f16') d[:] = arr f.close()
Ketika Anda memeriksa ukuran setiap file, Anda akan mendapatkan sesuatu seperti:
| File | Ukuran (b) |
|---|
| integer_1 | 102144 |
| integer_9 | 802144 |
| mengapung | 1602144 |
Hubungan antara ukuran dan tipe data jelas. Ketika Anda beralih dari integer dari 1 byte ke sebanyak 8 byte, ukuran file meningkat 8 kali, demikian pula, ketika Anda pergi ke 16 byte, dibutuhkan sekitar 16 kali lebih banyak ruang. Tetapi ruang bukan satu-satunya faktor penting untuk dipertimbangkan, Anda juga harus mempertimbangkan waktu yang diperlukan untuk menulis data ke disk. Semakin banyak Anda harus menulis, semakin lama waktu yang dibutuhkan. Tergantung pada aplikasi Anda, mungkin penting untuk mengoptimalkan pembacaan dan penulisan data.
Harap dicatat: jika Anda menggunakan tipe data yang salah, Anda juga dapat kehilangan informasi. Misalnya, jika Anda memiliki bilangan bulat 8 byte, dan Anda menyimpannya sebagai bilangan bulat 1 byte, nilainya akan terpotong. Saat bekerja di laboratorium, perangkat yang membuat berbagai jenis data sering tersedia. Beberapa kartu DAQ memiliki 16 bit, beberapa kamera bekerja dengan 8 bit, tetapi beberapa di antaranya dapat bekerja dengan 24 bit. Penting untuk memperhatikan tipe data, tetapi ini juga sesuatu yang mungkin tidak dipertimbangkan oleh pengembang Python, karena Anda tidak perlu nyatakan tipe.
Menarik juga untuk diingat bahwa array NumPy default akan mengapung dengan 8 byte (64 bit) per elemen. Ini bisa menjadi masalah jika, misalnya, Anda menginisialisasi array dengan nol untuk menyimpan data, yang seharusnya hanya 2 byte. Jenis array itu sendiri tidak akan berubah, dan jika Anda menyimpan data saat membuat kumpulan data (menambahkan data = my_array), maka format default akan menjadi "f8", yang merupakan array, tetapi bukan data nyata,
Memikirkan tipe data bukanlah sesuatu yang terjadi secara teratur jika Anda bekerja dengan Python dalam aplikasi sederhana. Namun, Anda harus menyadari bahwa tipe data ada dan apa dampaknya terhadap hasil Anda. Anda mungkin memiliki hard drive besar dan Anda tidak terlalu peduli dengan penyimpanan file, tetapi ketika Anda peduli dengan kecepatan penyimpanan Anda, tidak ada cara lain selain mengoptimalkan setiap aspek kode Anda, termasuk tipe data.
Kompresi dataSaat menyimpan data, Anda dapat memilih kompresi menggunakan algoritma yang berbeda. Paket h5py mendukung beberapa filter kompresi, seperti GZIP, LZF, dan SZIP. Saat menggunakan salah satu filter kompresi, data akan diproses dalam perjalanan ke disk, dan setelah membacanya akan dibongkar. Karenanya, tidak ada perubahan khusus dalam kode. Kami dapat mengulangi percobaan yang sama, menyimpan berbagai jenis data, tetapi menggunakan filter kompresi. Kode kami terlihat seperti ini:
import h5py import numpy as np arr = np.random.randn(100000) with h5py.File('integer_1_compr.hdf5', 'w') as f: d = f.create_dataset('dataset', (100000,), dtype='i1', compression="gzip", compression_opts=9) d[:] = arr with h5py.File('integer_8_compr.hdf5', 'w') as f: d = f.create_dataset('dataset', (100000,), dtype='i8', compression="gzip", compression_opts=9) d[:] = arr with h5py.File('float_compr.hdf5', 'w') as f: d = f.create_dataset('dataset', (100000,), dtype='f16', compression="gzip", compression_opts=9) d[:] = arr
Kami memilih gzip karena didukung di semua platform. Opsi compression_opts menentukan tingkat kompresi. Semakin tinggi level, semakin sedikit ruang yang dibutuhkan data, tetapi semakin lama prosesor harus bekerja. Level kompresi default adalah 4. Kita dapat melihat perbedaan dalam file kita berdasarkan pada level kompresi:
| Jenis | Tidak ada kompresi | Kompresi 9 | Kompresi 4 |
|---|
| integer_1 | 102144 | 28016 | 30463 |
| integer_8 | 802144 | 43329 | 57971 |
| mengapung | 1602144 | 1469580 | 1469868 |
Efek kompresi pada seluruh array data jauh lebih terlihat daripada pada dataset floating point. Saya serahkan kepada Anda untuk mencari tahu mengapa kompresi bekerja dengan sangat baik dalam dua kasus pertama, tetapi tidak pada yang terakhir. Sebagai petunjuk: Anda harus memeriksa data apa yang sebenarnya Anda simpan.
Membaca data yang dikompresi tidak mengubah kode yang dijelaskan di atas. Pustaka inti HDF5 akan menjaga ekstraksi data dari kumpulan data terkompresi menggunakan algoritma yang sesuai. Karenanya, jika Anda menerapkan kompresi untuk menyimpan, Anda tidak perlu mengubah kode yang Anda gunakan untuk membaca.
Kompresi data adalah alat tambahan yang harus Anda pertimbangkan bersama dengan semua aspek lain dari pemrosesan data. Anda harus mempertimbangkan waktu prosesor tambahan dan rasio kompresi yang efektif untuk mengevaluasi manfaat kompresi data dalam aplikasi Anda sendiri. Fakta bahwa transparan untuk kode hilir membuatnya sangat mudah untuk menguji dan menemukan solusi terbaik.
Ubah ukuran Kumpulan DataSaat Anda mengerjakan percobaan, terkadang tidak mungkin untuk mengetahui seberapa besar data Anda. Bayangkan Anda sedang merekam film, mungkin Anda akan menghentikannya setelah satu detik, mungkin setelah satu jam. Untungnya, HDF5 memungkinkan Anda untuk mengubah ukuran dataset dengan cepat dengan sedikit biaya komputasi. Panjang kumpulan data dapat dilampaui hingga ukuran maksimum. Ukuran maksimum ini ditentukan saat membuat dataset menggunakan kata kunci maxshape:
import h5py import numpy as np with h5py.File('resize_dataset.hdf5', 'w') as f: d = f.create_dataset('dataset', (100, ), maxshape=(500, )) d[:100] = np.random.randn(100) d.resize((200,)) d[100:200] = np.random.randn(100) with h5py.File('resize_dataset.hdf5', 'r') as f: dset = f['dataset'] print(dset[99]) print(dset[199])
Pertama, Anda membuat dataset untuk menyimpan 100 nilai dan mengatur ukuran maksimum menjadi 500 nilai. Setelah Anda menyimpan kumpulan nilai pertama, Anda dapat memperluas kumpulan data untuk menyimpan 100 nilai berikutnya. Anda dapat mengulangi prosedur sampai Anda mendapatkan kumpulan data dengan 500 nilai. , N- . , , .
, , . , - ( , , ):
with h5py.File('resize_dataset.hdf5', 'a') as f: dset = f['dataset'] dset.resize((300,)) dset[:200] = 0 dset[200:300] = np.random.randn(100) with h5py.File('resize_dataset.hdf5', 'r') as f: dset = f['dataset'] print(dset[99]) print(dset[199]) print(dset[299])
, , 200 200 299. , , .
, , , . 2D-, , — , 2D-. 3- HDF-, . , :
with h5py.File('movie_dataset.hdf5', 'w') as f: d = f.create_dataset('dataset', (1024, 1024, 1), maxshape=(1024, 1024, None )) d[:,:,0] = first_frame d.resize((1024,1024,2)) d[:,:,1] = second_frame
1024x1024 , . , , . maxshape None.
(Chunks), . (chunk) , .. . , , . , :
dset = f.create_dataset("chunked", (1000, 1000), chunks=(100, 100))
, dset [0: 100,0: 100] . dset [200: 300, 200: 300], dset [100: 200, 400: 500] . . h5py, :
(Chunking) . 10 KiB 1 MiB, . , , .
(auto-chunking), . , maxshape. :
dset = f.create_dataset("autochunk", (1000, 1000), chunks=True)
(Groups). HDF5, , . (groups), , . , :
import numpy as np import h5py arr = np.random.randn(1000) with h5py.File('groups.hdf5', 'w') as f: g = f.create_group('Base_Group') gg = g.create_group('Sub_Group') d = g.create_dataset('default', data=arr) dd = gg.create_dataset('default', data=arr)
Base_Group , Sub_Group. default . , , :
with h5py.File('groups.hdf5', 'r') as f: d = f['Base_Group/default'] dd = f['Base_Group/Sub_Group/default'] print(d[1]) print(dd[1])
, : Base_Group/default Base_Group/Sub_Group/default. , , , , . — keys():
with h5py.File('groups.hdf5', 'r') as f: for k in f.keys(): print(k)
, , for-. , . visit(), :
def get_all(name): print(name) with h5py.File('groups.hdf5', 'r') as f: f.visit(get_all)
,
get_all , , name. visit,
get_all. visit , , None, . , , Sub_Group,
get_all :
def get_all(name): if 'Sub_Group' in name: return name with h5py.File('groups.hdf5', 'r') as f: g = f.visit(get_all) print(g)
visit , , None, , get_all. Sub_Group, get_all , Sub_Group . , g , , :
with h5py.File('groups.hdf5', 'r') as f: g_name = f.visit(get_all) group = f[g_name]
. — , visititems, : name object. :
def get_objects(name, obj): if 'Sub_Group' in name: return obj with h5py.File('groups.hdf5', 'r') as f: group = f.visititems(get_objects) data = group['default'] print('First data element: {}'.format(data[0]))
visititems , , , . , , . . , , .
HDF5, HDF5, , . , , , , , , .. . , , 200x300x250. , , , , — , .
HDF5 -. .
import time import numpy as np import h5py import os arr = np.random.randn(1000) with h5py.File('groups.hdf5', 'w') as f: g = f.create_group('Base_Group') d = g.create_dataset('default', data=arr) g.attrs['Date'] = time.time() g.attrs['User'] = 'Me' d.attrs['OS'] = os.name for k in g.attrs.keys(): print('{} => {}'.format(k, g.attrs[k])) for j in d.attrs.keys(): print('{} => {}'.format(j, d.attrs[j]))
, attrs . , , . , . , , , update:
with h5py.File('groups.hdf5', 'w') as f: g = f.create_group('Base_Group') d = g.create_dataset('default', data=arr) metadata = {'Date': time.time(), 'User': 'Me', 'OS': os.name,} f.attrs.update(metadata) for m in f.attrs.keys(): print('{} => {}'.format(m, f.attrs[m]))
, , hdf5, . , . hdf5, . Python -. JSON, , , , pickle.
import json with h5py.File('groups_dict.hdf5', 'w') as f: g = f.create_group('Base_Group') d = g.create_dataset('default', data=arr) metadata = {'Date': time.time(), 'User': 'Me', 'OS': os.name,} m = g.create_dataset('metadata', data=json.dumps(metadata))
, . , . , json.dumps, . , HDF5. , json.loads:
Python
with h5py.File('groups_dict.hdf5', 'r') as f: metadata = json.loads(f['Base_Group/metadata'][()]) for k in metadata: print('{} => {}'.format(k, metadata[k]))
json , . YAML, XML .. , , , attr , , .
HDF5, . , , , . HDF , , , , , . , HDF .
HDF5 . , , . , . . SQL,
HDFql , SQL HDF5.
. , , - , , . , . , , .
HDF5 — , . , , , , . HDF5 — , , .
AKHIR
,
.