Գնահատել նախագիծը
← Բոլոր հրապարակումները

Նյու Յորքը քարտեզի վրա վայրկյանների ընթացքում. գեոտարածական կախարդանք Polars-ով

Տեսեք, թե ինչպես Polars-ը (pola.rs)՝ Rust-ի հետաքրքիր գրադարանը, կարող է կտրուկ արագացնել ձեր սկրիպտը՝ ցուցադրված NYC Taxi տվյալների գեոտարածական ինդեքսավորմամբ։

8 րոպե
ՏվյալներRustգրադարաններ

Այս գրառման մեջ կծանոթանանք 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-ը արժե ավելի խորը ուսումնասիրել. դա հզոր գեոտարածական ինդեքսավորման համակարգ է, որը տեղադրության տվյալների մշակումը դարձնում է զարմանալիորեն նրբագեղ և արդյունավետ։