Apache Arrow VS h5py

Apache Arrow : It contains a set of technologies that enable big data systems to process and move data fast

One of the main selling points of Polars over similar solutions such as Pandas is performance. Polars is written in highly optimized Rust and uses the Apache Arrow container format.

Kotlin DataFrame v0.14 comes with improvements for reading Apache Arrow format, especially loading a DataFrame from any ArrowReader. This improvement can be used to easily load results from analytical databases (such as DuckDB, ClickHouse) directly into Kotlin DataFrame.

Apache Arrow

It's this kind of certainty that underscores the vital role of the Apache Software Foundation (ASF). Many first encounter Apache through its pioneering project, the open-source web server framework that remains ubiquitous in web operations today. The ASF was initially created to hold the intellectual property and assets of the Apache project, and it has since evolved into a cornerstone for open-source projects worldwide. The ASF enforces strict standards for diverse contributions, independence, and activity in its projects, ensuring they can withstand the test of time as standards in software development. Many open-source projects strive to become Apache projects to gain the community credibility necessary for adoption as standard software building blocks, such as Apache Tomcat for Java web applications, Apache Arrow for in-memory data representation, and Apache Parquet for data file formatting, among others.

Apache Doris 2.1 has a data transmission channel built on Arrow Flight SQL. (Apache Arrow is a software development platform designed for high data movement efficiency across systems and languages, and the Arrow format aims for high-performance, lossless data exchange.) It allows high-speed, large-scale data reading from Doris via SQL in various mainstream programming languages. For target clients that also support the Arrow format, the whole process will be free of serialization/deserialization, thus no performance loss. Another upside is, Arrow Flight can make full use of multi-node and multi-core architecture and implement parallel data transfer, which is another enabler of high data throughput.

In comes Polars: a brand new dataframe library, or how the author Ritchie Vink describes it... a query engine with a dataframe frontend. Polars is built on top of the Arrow memory format and is written in Rust, which is a modern performant and memory-safe systems programming language similar to C/C++.

I learned yesterday about GoLang's assembler https://go.dev/doc/asm - after browsing how arrow is implemented for different languages (my experience is mainly C/C++) - https://github.com/apache/arrow/tree/main/go/arrow/math - there are bunch of .S ("asm" files) and I'm still not able to comprehend how these work exactly (I guess it'll take more reading) - it seems very peculiar.

The last time I've used inlined assembly was back in Turbo/Borland Pascal, then bit in Visual Studio (32-bit), until they got disabled. Then did very little gcc with their more strict specification (while the former you had to know how the ABI worked, the latter too - but it was specced out).

Anyway - I wasn't expecting to find this in "Go" :) But I guess you can always start with .go code then produce assembly (-S) then optimize it, or find/hire someone to do it.

How to Accomplish: Use libraries like h5py in Python to convert and store your datasets in HDF5 format. Assess the trade-offs between data precision and storage requirements to determine if 8-bit storage is suitable for your use case.

There's some good answers here, but another option I haven't seen suggested: Convert your txt file to HDF5 (Regardless if you follow my approach here, you should really consider converting your data to anything but a txt file). There's a nice library for working with it in python called h5py. The HDF format is designed specifically with working with very large sets of data (it even has compression options), often scientific in nature, but it's not a database. As far as how this fixes the specific issue you you've described, you can utilize numpy slicing to load one chunk your data at a time. Here's a stackoverflow answer which discusses a solution.

If it is a dataset, it should consist of individual instances. You could store these instances in separate files. Otherwise, HDF5 is a very convenient storage format. It allows random read/write access to elements of arrays stored on disk and has excellent Python support in form of the h5py package.

If possible, try to monitor your memory usage during execution and if you see that you are consistently exceeding ~50% (my own rule of thumb, though you may want to discuss this with others as well) of what's available. If you are consistently using most of the available memory, then it's likely worth taking a moment to evaluate whether you can operate on subsets of the data from start to finish, and leave the rest of the data on disk until you are almost ready to use it. Tools like h5py are very helpful in these kinds of situations.

Yea - I really struggled with getting the correct version on h5py to work with both tensorflow and allenai nlp modules. May be its about finding the right version of libraries. Github Issue. I ended up using pickle to save stuff, like John who commented on 26/03/2020 on the same(closed) issue.

Apply these to more issues, like in https://github.com/h5py/h5py/issues/1516