Նյու Յորքը քարտեզի վրա վայրկյանների ընթացքում. գեոտարածական կախարդանք Polars-ով
Տեսեք, թե ինչպես Polars-ը (pola.rs)՝ Rust-ի հետաքրքիր գրադարանը, կարող է կտրուկ արագացնել ձեր սկրիպտը՝ ցուցադրված NYC Taxi տվյալների գեոտարածական ինդեքսավորմամբ։
Այս գրառման մեջ կծանոթանանք Rust-ի սիրահարների համար հետաքրքիր գրադարանի հետ՝ Polars (pola.rs)։ Polars-ը DataFrame գրադարան է, որը կառուցված է բարձր արտադրողականության համար (եթե նախկինում օգտագործել եք համանման գրադարաններ, որոնցից հավանաբար ամենահայտնին Python էկոհամակարգի Pandas-ն է, անմիջապես կհասկանաք, թե ինչ է այն և ինչի համար է լավ)։ Polars-ը բնականաբար գրված է Rust-ով, բայց առաջարկում է նաև Python bindings, ուստի այն կարող եք օգտագործել երկու աշխարհներից որևէ մեկում։ Այն ստեղծվել է տվյալների արդյունավետ մշակման և մանիպուլյացիայի համար՝ աչքի ընկնող արտադրողականությամբ։
Ի տարբերություն Pandas-ի, որը հենվում է NumPy arrays-ի վրա, Polars-ը հիմնված է Apache Arrow սյունակային հիշողության ձևաչափի վրա և կարգավորված է անալիտիկ բեռների համար։ Դրա կատարման մոդելը նախապատվությունը տալիս է lazy կատարմանը, ինչը հնարավորություն է տալիս օպտիմալացնել հարցումները, և այն սովորաբար գերազանցում է Pandas-ին, հատկապես այնպիսի գործողություններում, ինչպիսիք են groupBy, join-ները և merge-երը, ինչպես նաև մեծ տվյալների հավաքածուների ֆիլտրման մեջ (որոշ benchmark-եր հասանելի են այստեղ)։
Լինելով գրված Rust-ով՝ Polars-ը հիշողությունն օգտագործում է շատ ավելի արդյունավետ, քան Pandas-ը։ Դրա սյունակային պահեստավորումն ավելի արդյունավետ է, և տվյալների կառուցվածքներն ունեն շատ ավելի քիչ ավելցուկ։ Բացի այդ, բազմաթիվ գործողություններ multithreaded են լռելյայն, ի տարբերություն Pandas-ի (եթե դիտավորյալ չներմուծեք լրացուցիչ Python գրադարաններ, օրինակ՝ Dask)։
Կարճ ձեռնարկ Pola.rs-ի մասին
Այս բլոգի գրառման համար, և Polars-ը իրական օգտագործմանը ավելի մոտ տվյալների հավաքածուի վրա փորձելու նպատակով, ընտրեցի NYC Taxi dataset-ը, որը բաղկացած է 3 ֆայլից՝ ընդհանուր 5,4 ԳԲ տվյալներով (2016 թվականի առաջին եռամսյակ)։
Սկսելու համար պետք է բեռնենք տվյալները և միավորենք դրանք մեկ lazy dataset-ի մեջ՝
let file_paths = vec!["nyc_taxi_data/yellow_tripdata_2016-01.csv",
"nyc_taxi_data/yellow_tripdata_2016-02.csv",
"nyc_taxi_data/yellow_tripdata_2016-03.csv",
];
// Create a vector to store individual LazyFrames
let mut lazy_frames: Vec<LazyFrame> = Vec::new();
println!("loading data...");
// Read each CSV file into a LazyFrame
for path in file_paths {
let lf = LazyCsvReader::new(path)
.with_has_header(true)
.with_try_parse_dates(false)
.with_low_memory(true)
.finish()?;
lazy_frames.push(lf);
}
Այս կոդը բեռնում է մի քանի CSV ֆայլ LazyFrame-ների մեջ՝ սովորական DataFrame-ների փոխարեն։ Արդյունքում հաշվարկները, ինչպիսիք են parsing-ը, ֆիլտրումը և այլն, միանգամից չեն կատարվում։ Փոխարենը մենք կառուցում ենք տրամաբանական պլան, որը Pola.rs շարժիչը կօպտիմալացնի և կկատարի հետագայում։
Polars-ը թույլ է տալիս տվյալները բեռնել կա՛մ eager, կա՛մ lazy եղանակով։ Eager մոտեցումն ավելի պարզ և ուղղակի է, ինչը հարմար է փոքր dataset-երի և արագ նախատիպավորման համար։ Սակայն այն ունի թերություններ, ինչպիսիք են օպտիմալացումների բացակայությունը և հնարավոր ավելի բարձր հիշողության օգտագործումը (Polars-ը չի դեն նետի այն սյունակները, որոնք ձեր հարցումները իրականում երբեք չեն օգտագործում)։
// Create UnionArgs for concat function
let union_args = UnionArgs {
parallel: false,
..Default::default()
};
// Concatenate all LazyFrames vertically
let combined_lf = concat(lazy_frames, union_args)?;
// Collect data
let df = combined_lf.collect()?;
Մի քանի աղբյուրից տվյալները մեր lazy frame-ներում բեռնված լինելով՝ կարող ենք դրանք միավորել մեկ համակցված data frame-ի մեջ։ Դրա համար օգտագործում ենք UnionArgs struct-ը, որը ասում է Polars-ին, թե ինչպես միացնել frame-ները։
Լավ, մեր բոլոր տվյալներն այժմ հավաքված են և պատրաստ են մշակման։ Այս կարճ ձեռնարկի համար ընտրեցի դիտարկել ընդամենը 2 սյունակ՝ dropoff_latitude և dropoff_longitude, որոնք ցույց են տալիս, թե որտեղ են NYC տաքսիները ուղևորներին իջեցնում։ Անշուշտ կան այլ հետաքրքիր սյունակներ, ինչպիսիք են թեյավճարի գումարը, ընդհանուր գումարները և այլն, բայց մենք փնտրում ենք տեղադրությունը, որպեսզի փորձարկենք այն H3 գրադարանով և ցուցադրենք ինչ-որ բան քարտեզի վրա։
Ընտրում ենք սյունակները և փորձում ստանալ յուրաքանչյուրի տիպավորված f64 ներկայացումը։
let lat_series = df.column("dropoff_latitude")?;
let lng_series = df.column("dropoff_longitude")?;
let lat_vec = lat_series.f64()?;
let lng_vec = lng_series.f64()?;
Մեր տվյալներն այժմ պատրաստ են մշակման։ Այս պարզ օրինակում lat/lng կետերը կվերածենք H3 բջիջների և կհաշվենք, թե քանի գրառում է հայտնվում յուրաքանչյուր H3 բջջում։
// HashMap to count frequencies of each H3 cell
let mut h3_counts: HashMap<String, u32> = HashMap::new();
// Convert lat/lng to H3 cells and count occurrences
for i in 0..lat_vec.len() {
if let (Some(lat), Some(lng)) = (lat_vec.get(i), lng_vec.get(i)) {
let latlng = LatLng::new(lat, lng).expect("Invalid coordinates");
let h3_index = latlng.to_cell(Resolution::Nine);
let h3_str = h3_index.to_string();
// Store the H3 index as a string
h3_cells.push(h3_str.clone());
// Increment count for this H3 cell
*h3_counts.entry(h3_str).or_insert(0) += 1;
} else {
h3_cells.push(String::new()); // Handle missing values
}
}
Տվյալների այս պարզ մշակումը ավարտելու համար մեր data frame-ին ավելացնում ենք h3_index սյունակը, որպեսզի այն հետագայում կարողանանք օգտագործել JavaScript-ով քարտեզ ստեղծելիս։
// Add H3 cell indices to the dataframe
let h3_series = Series::new(PlSmallStr::from_str("h3_index"), &h3_cells);
let mut df_with_h3: DataFrame = df.clone();
df_with_h3.with_column(h3_series)?;
Ինդեքսը ձեռքի տակ ունենալով՝ կարող ենք լրացնել պարզ html էջ՝ օգտագործելով leaflet.js և h3-js.umd.js՝ մեր պոլիգոնները Նյու Յորք քաղաքի քարտեզի վրա ցուցադրելու համար։
Ավելացրի նաև հաճախականության heat map, որպեսզի հեշտ լինի նկատել ամենահաճախ օգտագործվող իջեցման վայրերը (նշված կարմիրով)։
H3 հաճախականությունները վերածվում են json-ի և տեղադրվում js օբյեկտի մեջ, որն էջը հետագայում օգտագործում է՝
// Convert HashMap to a JSON object
let h3_frequency_json = h3_counts
.iter()
.map(|(h3, count)| format!("\"{}\":{}", h3, count))
.collect::<Vec<_>>()
.join(",\n ");
Կատարում ենք նաև մի քանի հիմնական հաշվարկներ, որոնք անհրաժեշտ են լեգենդի համար, օրինակ՝ ամենաբարձր հաճախականության արժեքը բոլոր ստեղծված h3 պոլիգոնների միջև՝
let max_count = h3_counts.values().max().cloned().unwrap_or(1);
Սկրիպտը ստեղծված html-ը գրում է նոր ֆայլում, և արդյունքը html էջի վրա պարզ leaflet քարտեզ է՝ tooltip-ներով (ցույց են տալիս հաճախականությունը) և լեգենդով, որը բացատրում է heatmap-ի գույները։
Արագացնելը
Առայժմ լավ է, և Pola.rs-ը առաջարկում է հիանալի developer experience, բայց թվում է՝ կարելի է մի փոքր ավելի արագ աշխատեցնել։ Կոդն ինչպես որ կա, ամբողջ ստեղծումը տևում է մոտ 5 րոպե (00:05:00.105)։ Հաշվի առնելով, որ այն մշակում է 5,4 ԳԲ տվյալ, դա դեռ տպավորիչ է, բայց կա բարելավման տեղ։
Առաջին քայլը այն է, որ հնարավորինս շուտ դեն նետենք ամեն սյունակ, որն անհրաժեշտ չի լինի, մինչև մեր lazy data frame-ի վրա կանչենք .collect()։
Polars-ի lazy data frame-ները գալիս են որոշ ավտոմատ կիրառվող օպտիմալացումներով։ Այդուհանդերձ, չօգտագործվող սյունակներից հնարավորինս շուտ ազատվելը միշտ լավ պրակտիկա է։
// Read each CSV file into a LazyFrame
for path in file_paths {
let lf = LazyCsvReader::new(path)
.with_has_header(true)
.with_try_parse_dates(false)
.with_low_memory(true)
.finish()?;
let lf_lat_lng = lf.select([
col("dropoff_latitude"),
col("dropoff_longitude"),
]);
lazy_frames.push(lf_lat_lng);
}
Այս պարզ հնարքը խնայեց մոտ 16 վայրկյան՝ մեր սկրիպտի ընդհանուր end-to-end աշխատաժամանակը հասցնելով 00:04:43.905-ի։
Ուշադիր ընթերցողները հավանաբար նկատել են, որ մեր union_args struct-ում parallel: false դաշտը սահմանված էր, երբ lazy frame-ները միավորում էինք մեկ միավորի մեջ։ Դա միտումնավոր էր. այս դրոշը true դարձնելը մեզ տալիս է ևս 19 վայրկյան բարելավում, քանի որ Polars շարժիչն այդ դեպքում կարող է այս գործողության համար օգտագործել մեր մեքենայի մի քանի միջուկ։
UnionArgs-ը միայն հիմնական օրինակ է. Polars-ի հետ աշխատելիս հետևեք այլ գործողությունների, որոնք կարող են օգտվել զուգահեռականությունից և ձեր կոդը շատ ավելի արագ դարձնել, օրինակ՝
1. .par_apply() on ChunkedArrays
let result = some_chunked_array.par_apply(|v| expensive_fn(v));
2. .with_streaming(true) on joins and groupbys
lazy_df
.join(other, ...)
.with_streaming(true)
3. CsvReader::with_n_threads(n) (Eager only)
let df = CsvReader::from_path("file.csv")?
.with_n_threads(4)
.finish()?;
Ներքին գործողությունների մեծ մասի համար, ինչպիսիք են .groupby(), .join(), .agg() և այլն, Polars-ը լռելյայն աշխատում է զուգահեռ, եթե բացահայտորեն չանջատեք այն, բայց միշտ արժե ստուգել փաստաթղթերը և միացնել զուգահեռ ընտրանքները, որտեղ դրանք կան։
Մեր union args-ում parallel-ը միացնելով՝ հասնում ենք 00:04:24.839-ի։
Երբ սկրիպտն աշխատեցնեք ինքներդ, շուտով կտեսնեք, որ lat/lng զույգերը H3 բջիջների վերածելը խլում է ժամանակի մեծ մասը։ Դա պայմանավորված է նրանով, որ data frame-ի յուրաքանչյուր գրառումով անցնում ենք սովորական for ցիկլով, ինչը անշուշտ կարելի է բարելավել։
Եթե Polars-ի հետ որոշ փորձ ունեք, հավանաբար արդեն գիտեք սա. ներսում Polars-ը հենվում է Rayon տվյալների զուգահեռականության գրադարանի վրա։ Գրառումները մեկ-մեկ մշակող սովորական for ցիկլի փոխարեն կարող ենք հեշտությամբ օգտագործել Rayon՝ մեր սեփական կոդը զուգահեռացնելու և զգալիորեն արագացնելու համար։
Rayon-ը thread-երի վրա բարձր մակարդակի աբստրակցիա է։ Այն աշխատեցնում է զուգահեռ for ցիկլեր և map/filter/collect շղթաներ մի քանի CPU միջուկների վրա։ Այն նաև շատ անվտանգ է և հաճելի օգտագործման համար. առանց thread-երի ձեռքով կառավարման, առանց Mutex-ների, առանց RwLock-ների, առանց unsafe-ի և առանց Pinning-ի։
Մեր կոդը զուգահեռացնելու փոքր բարդությունն այն է, որ մենք ընթացքում հաշվում ենք յուրաքանչյուր բջջի հանդիպումները։ Սա լուծելու համար հաշվարկը պետք է բաժանենք երկու առանձին քայլի՝ մեկը, որը տվյալները վերածում է բջիջների, և մյուսը, որը հաշվում է հանդիպումները։
// Combine into (index, lat, lng) tuples and process in parallel
let results: Vec<Option<String>> = (0..lat_vec.len())
.into_par_iter()
.map(|i| {
match (lat_vec.get(i), lng_vec.get(i)) {
(Some(lat), Some(lng)) => {
let latlng = LatLng::new(lat, lng).ok()?;
let h3_index = latlng.to_cell(Resolution::Nine);
Some(h3_index.to_string())
}
_ => None,
}
})
.collect();
Այնուհետև հաշվում ենք հանդիպումները և տվյալները հավաքում h3_cells-ում, ինչպես նախկինում՝
let mut h3_cells:Vec<String> = Vec::with_capacity(results.len());
let mut h3_counts: HashMap<String, u32> = HashMap::new();
for maybe_h3 in results {
if let Some(h3_str) = maybe_h3 {
*h3_counts.entry(h3_str.clone()).or_insert(0) += 1;
h3_cells.push(h3_str);
} else {
h3_cells.push(String::new());
}
}
Այժմ ունենք՝ Elapsed time: 00:00:50.339, ինչը 3 րոպե 24 վայրկյանով ավելի արագ է, քան նախորդ արդյունքը, և 4 րոպե 10 վայրկյանով ավելի արագ, քան որտեղից սկսեցինք։
Վերջնական մտքեր
Այս բլոգի գրառմամբ ուզում էի ցույց տալ, որ՝
- Pola.rs-ը հաճելի է և կարող է օգտագործվել շատ նման Pandas-ին, բայց զգալիորեն ավելի արագ, type-safe Rust սկրիպտավորմամբ։
- Ինչ տվյալների մանիպուլյացիայի գրադարան էլ ընտրեք, հնարավոր օպտիմալացումները նկատի ունեցեք հենց սկզբից. դրանք կարող են ձեր սկրիպտը շատ ավելի արագ դարձնել և երբեմն հենց դրանք են պատճառը, որ այն ընդհանրապես աշխատում է։
- h3-ը արժե ավելի խորը ուսումնասիրել. դա հզոր գեոտարածական ինդեքսավորման համակարգ է, որը տեղադրության տվյալների մշակումը դարձնում է զարմանալիորեն նրբագեղ և արդյունավետ։