பைத்தானில் மிகப்பெரியஅளவிலான தரவுத் தொகுப்புகளைக் கையாளுகின்ற பணியானது பொதுவாகஅனைத்து நிரலாளர்களுக்கும் உண்மையில் ஒருமிகப்பெரிய சவாலாக இருக்கலாம், குறிப்பாக கணினியில் எளிதில் கையாளக்கூடிய சிறுசிறு தரவுத்தொகுப்புகளுடன் பணிபுரியும் போது மிகப்பெரியஅளவிலான தரவுத் தொகுப்புகளைக் கையாளுவது என்பது உண்மையில் மிகமுக்கியமான சவாலாக இருக்கக்கூடும். இதற்காக கண்டிப்பாக பயந்திடவேண்டாம்! அவ்வாறான மிகப்பெரிய தரவைகூட திறம்பட செயலாக்கவும் பகுப்பாய்வு செய்யவும் உதவுவதற்கான கருவிகளாலும் தந்திரங்களுடனான செயலிகளாலும் பைதான் ஆனது நிரம்பியுள்ளது என்பதே உண்மையான களநிலவரமாகும்.
அதனடிப்படையில் இந்த பயிற்சிகட்டுரையில், அதிக கவனம் செலுத்துவதற்கான pro போன்ற பெரிய தரவுத்தொகுப்புகளைச் செயலாக்குவதற்கான அத்தியாவசிய உதவிக்குறிப்புகளை காணலாம்:
பயிற்சியை தொடங்குவோமா!
1. Listsஎன்பதற்குப் பதிலாக Generatorsஎன்பதை பயன்படுத்திடுக
பைத்தானில் பெரிய தரவுத்தொகுப்புகளைச் செயலாக்கும்போது, எல்லாவற்றையும் ஒரு Listsஇல் பதிவேற்றம்செய்வது அதிக சிரமமில்லாமல் இருப்பதால் நம்மனைவரையும் இதனையே அடிக்கடி பயன்படுத்திகொள்ளுமாறு நம்மை தூண்டுகிறது. ஆனால் பொதுவாக இது ஒரு மிகப்பெரியஅளவிலான நினைவகத்தை எடுத்துக்கொள்ளும் அதாவது நாம் செயல்படுத்தி பயன்பெற விரும்புகின்ற கோப்பினை முழுமையாக நினைவகத்தில் பதிவேற்றம் செய்த பின்னரே நாம் அதனை பயன்படுத்திகொள்ளமுடியும் . மறுபுறம், Generators ஆனது, தேவைப்படும் போது மட்டுமே தேவையான தரவை பதிவேற்றம் செய்கின்றன-செயலில் இருக்கும்போது-அந்த பணியை நன்குதிறம்பட செயல்படுத்துவதுடன் அதற்கான நினைவகத்தை திறம்பட கையாளுகிறது.
நம்மிடம் server logs or user activity data எனும் மிகப்பெரிய பதிவுக் கோப்பு இருப்பதாக கொள்க – அதை வரிக்கு வரி பகுப்பாய்வு செய்ய வேண்டும். Generatorsஐ பயன்படுத்தி, இதற்கானமுழு கோப்பையும் நினைவகத்தில் பதிவேற்றம் செய்திடாமல் உள்ளடக்கங்களை- குறிப்பிட்டஒரு நேரத்தில் ஒருவரிமட்டுமே என்றவாறு வரிவரியாகப் படித்து செயலாக்கம் செய்திடலாம்அதற்கான குறிமுறைவரிகள் பின்வருமாறு
def read_large_file(file_name):
with open(file_name, ‘r’) as file:
for line in file:
yield line
பைதானில்Generatorஎனும் செயலியைப் பயன்படுத்திடும்போது, ஒரு Generator ஆனது ஒரு பொருளை மட்டுமேத் தருகிறது, முழுபட்டியலை அன்று. இந்த Generator மூலம் அதே பணியை மீண்டும் திரும்ப திரும்ப செய்திடலாம், அதன்மூலம் ஒவ்வொரு வரியையும் தனித்தனியாக செயலாக்கலாம்.
2. Multiprocessingஎன்பதுடன் இணையாக செல்க
பொதுவாக தரவானது ஒரு செயலி மையத்திற்கு மட்டுப்படுத்தப்பட்டிருந்தால், பெரிய தரவுத்தொகுப்புகளைச் செயலாக்குகின்ற பணி மிகமெதுவாக இருக்கும். பைத்தானின் Multiprocessing எனும்தகவமைவுஆனது பல CPU இன்உள்ளகங்களில் பணிகளைப் பிரிக்க அனுமதிக்கிறது. இது செயலிகளை கணிசமான அளவில் விரைவாக செயல்படுமாறு செய்கிறது.
வீட்டு விலைகளுடன் கூடிய ஒரு பெரிய தரவுத்தொகுப்பு உள்ளதாக கொள்க அதன்வெளிப்புறவிவரங்களை அகற்றி தரவை இயல்பாக்க விரும்புவதாக கொள்க. Multiprocessingஇன் மூலம், செயலாக்கத்தின் நேரத்தைக் குறைக்க இந்தப் பணியை இணையான பகுதிகளாகக் கையாளலாம்அதற்கான குறிமுறைவரிகள் பின்வருமாறு.
import pandas as pd
import numpy as np
from multiprocessing import Pool
Function to clean and normalize data for each chunk
def clean_and_normalize(df_chunk):
Remove top 5% as outliers in the ‘price’ column
df_chunk = df_chunk[df_chunk[‘price’] < df_chunk[‘price’].quantile(0.95)]
Normalize the ‘price’ column
df_chunk[‘price’] = (df_chunk[‘price’] – df_chunk[‘price’].min()) / (df_chunk[‘price’].max() – df_chunk[‘price’].min())
return df_chunk
Function to read data in chunks and process it in parallel
def process_in_chunks(file_name, chunk_size):
chunks = pd.read_csv(file_name, chunksize=chunk_size)
with Pool(4) as pool: # Adjust the number of processes for your CPU
Process each chunk in parallel and combine results
cleaned_data = pd.concat(pool.map(clean_and_normalize, chunks))
return cleaned_data
if name == “__main _”:
cleaned_df = process_in_chunks(‘large_house_data.csv’, chunk_size=100000)
print(cleaned_df.head())
இதன் துண்டுதுண்டுகளான குறிமுறைவரிகளின் ஒவ்வொரு துண்டிலும், அதிக விலையுள்ள வெளிப்புறவிவரங்களை வடிகட்டி, விலையின் நெடுவரிசையை இயல்பாக்குகின்றது. Pool(4), ஐப் பயன்படுத்தி, ஒரே நேரத்தில் தனித்தனி துண்டுகளைக் கையாள நான்கு செயல்முறைகளை உருவாக்குகின்றது, தரவைசுத்தம்செய்தலையும் இயல்பாக்குதலையும் விரைவு படுத்துகின்றது. பல உள்ளகங்கள் தனித்தனிதுகள்களில் செயல்படுவதால், செயலாக்கம் மிக விரைவாக இருக்கின்றது.
குறிப்பு: இது பயனுள்ள உதவிக்குறிப்புகளை உள்ளடக்கிய ஒரு குறுகிய வழிகாட்டியாகும் குறிப்பிட்ட தரவுத்தொகுப்பில் கவனம் செலுத்தாது. ஆனால் வங்கியின் சந்தைப்படுத்தல் தரவுத்தொகுப்பு அல்லது NYC TLC பயண பதிவு தரவு போன்ற தரவுத்தொகுப்புகளைப் பயன்படுத்தலாம். குறிமுறைவரிகளின் எடுத்துக்காட்டுகளில், large_dataset.csv போன்ற பொதுவான கோப்புப் பெயர்களைப் பயன்படுத்துவது வழக்கமாகும்.
3.துண்டுதுண்டுகளான செயலாக்கத்திற்கு ‘Pandas’ chunksizeஎன்பதைப் பயன்படுத்திடுக
தரவு பகுப்பாய்வு கையாளுதலுக்கு Pandas சிறந்தது, ஆனால் DataFrame இல் ஒரு பெரிய தரவுத்தொகுப்பை பதிவேற்றம்செய்வது நினைவகத்தில் அழுத்தத்தை ஏற்படுத்தும். அதிர்ஷ்டவசமாக, pd.read_csv() இல் உள்ள chunksize ஆனது, பெரிய தரவுத்தொகுப்புகளை நிர்வகிக்கக்கூடிய துண்டுகளாக(“chunks.”) அல்லது செயலாக்க நம்மை அனுமதிக்கிறது.எடுத்துக்காட்டாக விற்பனைத் தரவுகளுடன் பணிபுரிவதாவும் மொத்த விற்பனையைக் கணக்கிட விரும்புவதாகவும்கொள்க. Chunksize ஐப் பயன்படுத்தி, விற்பனை மதிப்புகளை துண்டுதுண்டாகப் படித்து ஒட்டுமொத்தமாக சுருக்கிக் கொள்ளலாம் அதற்கான எடுத்துக்காட்டு குறிமுறைவரிகள் பின்வருமாறு:.
import pandas as pd
total_sales = 0
chunk_size = 100000 # Define chunk size to read data in batches
Load data in chunks and process each chunk
for chunk in pd.read_csv(‘large_sales_data.csv’, chunksize=chunk_size):
total_sales += chunk[‘sales’].sum() # Summing up sales column in each chunk
print(f”Total Sales: {total_sales}”)
இதில்ஒவ்வொரு பகுதியும் சுதந்திரமாகதனித்தனியாக பதிவேற்றம்செய்யப்பட்டு செயலாக்கப்படுகிறது, நினைவகத்தை ஆக்கிரமிப்புசெய்திடாமல் பெரிய கோப்புகளுடன் பணி செய்ய நம்மை அனுமதிக்கிறது. ஒவ்வொரு துண்டிலும் உள்ள விற்பனையைத் தொகுத்து, படிப்படியாக மொத்தத்தை உருவாக்கிடலாம். எந்த நேரத்திலும் கோப்பின் ஒரு பகுதி மட்டுமே நினைவகத்தில் இருக்கும், எனவே இதன்மூலம் பெரிய கோப்புகளை சிக்கலின்றி கையாளமுடியும்.
4. இணையான கணினியின்செயல்பாட்டிற்கு Dask ஐப் பயன்படுத்திடுக
பொதுவாக நமக்கு பாண்டாக்களுடன்பணிபுரிவது வசதியாக இருந்தாலும், அதிக திறன் தேவைப்படும்போது, இணையான கணினியுடன் வசதியான அடுத்த படிமுறையை Dask வழங்குகிறது. Dask dataframeஆனது hood என்பதன் கீழ் Pandas களைப் பயன்படுத்திகொள்கிறது. அதுமட்டுமின்றி நாம் ஏற்கனவே Pandas களுடன் பணிபுரிந்து கொண்டிருந்தால், Daskஐ விரைவாகப் பெற்றிடலாம். பெரிய தரவுத்தொகுப்புகளில் இயந்திரக் கற்றல் மாதிரிகளைப் பயிற்றுவிக்க, Scikit-learn , XGBoost போன்ற நூலகங்களுடன் இணைந்து Daskஐப் பயன்படுத்தி கொள்ளலாம். அதனோடு கூடுதலாக Daskஐ pip என்பதுடன் நிறுவுகை செய்திடலாம். எடுத்துகாட்டாக ஒரு பெரிய தரவுத்தொகுப்பில் ஒரு வகைக்கான சராசரி விற்பனையைக் கணக்கிட விரும்புவதாகக்கொள்க அதற்கான குறிமுறைவரிகள் பின்வருமாறு:
import dask.dataframe as dd
Load data into a Dask DataFrame
df = dd.read_csv(‘large_sales_data.csv’)
Group by ‘category’ and calculate mean sales (executed in parallel)
mean_sales = df.groupby(‘category’)[‘sales’].mean().compute()
print(mean_sales)
எனவே, Pandasஇவின் தொடரியலைப் பயன்படுத்தினால், dask.ஆனது நமக்கு ஏற்கனவே தெரிந்ததாக உணர்ந்திடலாம், ஆனால் இதன்மூலம் மிகப் பெரிய தரவுத்தொகுப்புகளைகூட சிறப்பாகக் கையாள முடியும்.
5. பெரிய தரவு செயலாக்கத்திற்கு PySpark உதவிடும் என்பதைக் கவணத்தில் கொள்க
உண்மையில் பெரிய தரவுத்தொகுப்புகள் – நூற்றுக்கணக்கான ஜிகாபைட்கள் அல்லது அதற்கு மேற்பட்டவை எனக்கொள்க – அவ்வாறான கோப்புகளை கூட எளிதாக கையாளுவதற்காக PySpark ஐப் பயன்படுத்திகொள்ளலாம். PySpark ஆனது கொத்துகள் (clusters) முழுவதிலும் விநியோகிக்கப்படுகின்ற தரவைக் கையாளுமாறு வடிவமைக்கப் பட்டுள்ளது, இது பாரிய தரவு செயலாக்கத்திற்கு மிகவும்ஏற்றது.
எடுத்துகாட்டாக மில்லியன் கணக்கான திரைப்பட மதிப்பீடுகளைக் கொண்ட தரவுத் தொகுப்பில் பணிபுரிவதாகவும் ஒவ்வொரு வகைக்கும் சராசரி மதிப்பீட்டைக் கண்டறிய விரும்புவதாக கொள்க அதற்கான குறிமுறைவரிகள் பின்வருமாறு.
from pyspark.sql import SparkSession
Start a Spark session
spark = SparkSession.builder.appName(“MovieRatings”).getOrCreate()
Load the dataset into a Spark DataFrame
df = spark.read.csv(‘movie_ratings.csv’, header=True, inferSchema=True)
Perform transformations (e.g., group by genre and calculate average rating)
df_grouped = df.groupBy(‘genre’).mean(‘rating’)
Show the result
df_grouped.show()
PySpark ஆனது பல்வேறு கணினிகளில் அல்லது தரவுமையங்களில் தரவு , கணக்கீடு ஆகிய இரண்டையும் எளிதாக கையாளுகின்றது.
முடிவாக
பைத்தானானது பெரிய தரவுத்தொகுப்புகளைக் கையாளுவதற்கான மிகச்சரியான கருவிகளை தன்னகத்தேக் கொண்டு அவைகளை எளிதாக சமாளிக்கக்கூடியது.
Generatorsஎன்பது நினைவக திறனின் தரவை செயலாக்குவதற்கான கருவியாகும். Multiprocessing ஆனது விரைவான செயலாக்கத்திற்காக CPU உள்ளகங்கள் முழுவதும் பணியைப் பிரித்து செயல்படுத்திட அனுமதிக்கிறது. நினைவக-திறனுள்ள செயலாக்கத்திற்காக துணுக்குகளில் தரவை பதிவேற்றம் செய்திட, பாண்டாக்களில் chunksize என்பதைப் பயன்படுத்திகொள்க. Dask, ஆனது இணையான கணினிக்கான பாண்டாக்கள் போன்ற நூலகமாகும், பெரிய தரவுத்தொகுப்புகளுக்கு மிகச்சிறந்தது. PySparkஆனது பெரிய தரவுகளின் விநியோகிக்கப்பட்ட செயலாக்கத்திற்கான கருவியாகும்
மகிழ்ச்சியான பைத்தானில் குறிமுறைவரிகளின் அனுபவத்திற்கான முன்கூட்டியேயான வாழ்த்துக்கள்!