Bet Lavender

Tentang aplikasi ini

🔥 Selamat datang di Bet Lavender — Jelajahi tren terbaru tentang kwiff-betting!

Apa yang Sebenarnya Dilakukan oleh __slots__ Python?

Bagaimana jika ada cara untuk membuat kode Python Anda lebih cepat? __slots__ di Python mudah diimplementasikan dan dapat meningkatkan performa kode sambil mengurangi penggunaan memori.

Dalam artikel ini, kita akan membahas cara kerjanya menggunakan proyek ilmu data dari dunia nyata, di mana Allegro menggunakan ini sebagai tantangan untuk proses rekrutmen ilmu data mereka. Namun, sebelum masuk ke proyek ini, mari kita bangun pemahaman yang kuat tentang apa yang dilakukan __slots__.

Di Python, setiap objek menyimpan kamus atributnya. Ini memungkinkan Anda menambah, mengubah, atau menghapus atribut, tetapi juga memiliki biaya: memori ekstra dan akses atribut yang lebih lambat. Deklarasi __slots__ memberi tahu Python bahwa hanya atribut inilah yang diperlukan objek ini. Ini semacam batasan, tetapi akan menghemat waktu. Mari lihat dengan contoh.

class WithoutSlots: def __init__(self, name, age): self = name self = age class WithSlots: __slots__ = ['name', 'age'] def __init__(self, name, age): self = name self = age
Pada kelas kedua, __slots__ memberi tahu Python untuk tidak membuat kamus untuk setiap objek. Sebagai gantinya, ia menyediakan tempat tetap di memori untuk nilai nama dan usia, membuatnya lebih cepat dan mengurangi penggunaan memori.

Mengapa Menggunakan __slots__?

- Memori: Objek memakan lebih sedikit ruang ketika Python melewatkan pembuatan kamus.
- Kecepatan: Mengakses nilai lebih cepat karena Python tahu di mana setiap nilai disimpan.
- Bug: Struktur ini menghindari bug tersembunyi karena hanya atribut yang ditentukan yang diizinkan.

Menggunakan Tantangan Ilmu Data Allegro sebagai Contoh

Dalam proyek data ini, Allegro meminta kandidat ilmu data untuk memprediksi harga laptop dengan membangun model pembelajaran mesin. Ada tiga dataset berbeda: train_dataset.json, val_dataset.json, dan test_dataset.json. Mari lanjutkan dengan proses eksplorasi data.

Eksplorasi Data

Sekarang mari muat salah satunya untuk melihat struktur dataset.

with open('train_dataset.json', 'r') as f: train_data = json(f) df = pdame(train_data).dropna().reset_index(drop=True) df()
Selanjutnya, lihat kolom dengan df() dan periksa kolom numerik dengan dfbe().

Eksplorasi Data dengan __slots__ vs Kelas Reguler

Mari buat kelas bernama SlottedDataExploration yang menggunakan atribut __slots__. Ini hanya mengizinkan satu atribut bernama df.

class SlottedDataExploration: __slots__ = ['df'] def __init__(self, df): self = df def info(self): return df() def head(self, n=5): return df(n) def tail(self, n=5): return df(n) def describe(self): return dfbe(include='all')
Sekarang bandingkan dengan kelas reguler tanpa __slots__.

class DataExploration: def __init__(self, df): self = df def info(self): return df() def head(self, n=5): return df(n) def tail(self, n=5): return df(n) def describe(self): return dfbe(include='all')

Perbandingan Performa: Tolok Ukur Waktu

Sekarang ukur performa dengan mengukur waktu dan memori menggunakan modul pympler.

import time from pympler import asizeof start_normal = time() de = DataExploration(df) _ = de() _ = de() _ = debe() _ = de() end_normal = time() normal_duration = end_normal - start_normal normal_memory = asizeoff(de) start_slotted = time() sde = SlottedDataExploration(df) _ = sde() _ = sde() _ = sdebe() _ = sde() end_slotted = time() slotted_duration = end_slotted - start_slotted slotted_memory = asizeoff(sde) print(f"⏱️ Durasi kelas normal: {normal_duration:.4f} detik") print(f"⏱️ Durasi kelas slotted: {slotted_duration:.4f} detik") print(f"📦 Penggunaan memori kelas normal: {normal_memory:.2f} bytes") print(f"📦 Penggunaan memori kelas slotted: {slotted_memory:.2f} bytes")
Hasilnya: kelas slotted 46,45% lebih cepat, tetapi penggunaan memori sama untuk contoh ini.

Pembelajaran Mesin dalam Aksi

Sekarang, lanjutkan dengan pembelajaran mesin. Pertama, lakukan pemisahan train dan test menggunakan indeks dari dataset yang ada. Kemudian, format data untuk numpy menggunakan.ravel().

train_indeces = train_df.dropna().index val_indeces = val_df.dropna().index test_indeces = test_df.dropna().index train_df = new_df.loc[train_indeces] val_df = new_df.loc[val_indeces] test_df = new_df.loc[test_indeces] X_train = train_df[selected_features].to_numpy() X_val = val_df[selected_features].to_numpy() X_test = test_df[selected_features].to_numpy() y_train = df[train_indeces][label_col].to_numpy().ravel() y_val = df[val_indeces][label_col].to_numpy().ravel() y_test = df[test_indeces][label_col].to_numpy().ravel()
Menerapkan model pembelajaran mesin:

import numpy as np import pandas as pd from sklearn_model import LinearRegression from sklearns import mean_squared_error from sklearn import DecisionTreeRegressor from sklearnle import RandomForestRegressor from sklearnle import GradientBoostingRegressor from sklearnle import ExtraTreesRegressor from sklearnle import VotingRegressor from sklearn import linear_model from sklearn_network import MLPRegressor from sklearnne import make_pipeline from sklearncessing import StandardScaler, MaxAbsScaler import matplotlib as plt from sklearn import tree import seaborn as sns def rmse(y_true, y_pred): return mean_squared_error(y_true, y_pred, squared=False) def regression(regressor_name, regressor): pipe = make_pipeline(MaxAbsScaler(), regressor) pipe(X_train, y_train) predicted = pipet(X_test) rmse_val = rmse(y_test, predicted) print(regressor_name, ':', rmse_val) pred_df[regressor_name+'_Pred'] = predicted plt(regressor_name) plt(regressor_name) plt('predicted') plt('actual') snst(y=y_test,x=predicted) regressors = { 'Linear': LinearRegression(), 'MLP': MLPRegressor(random_state=42, max_iter=500, learning_rate="constant", learning_rate_init=0.6), 'DecisionTree': DecisionTreeRegressor(max_depth=15, random_state=42), 'RandomForest': RandomForestRegressor(random_state=42), 'GradientBoosting': GradientBoostingRegressor(random_state=42, criterion='squared_error', loss='squared_error',learning_rate=0.6, warm_start=True), 'ExtraTrees': ExtraTreesRegressor(n_estimators=100, random_state=42), } pred_df = pdame(columns =["Actual"]) pred_df["Actual"] = y_test for key in regressors(): regression(key, regressors[key])

Pembelajaran Mesin dengan __slots__ vs Kelas Reguler

Sekarang implementasikan dengan __slots__.

class SlottedMachineLearning: __slots__ = ['X_train', 'y_train', 'X_test', 'y_test', 'pred_df'] def __init__(self, X_train, y_train, X_test, y_test): self.X_train = X_train self.y_train = y_train self.X_test = X_test self.y_test = y_test self_df = pdame({'Actual': y_test}) def rmse(self, y_true, y_pred): return mean_squared_error(y_true, y_pred, squared=False) def regression(self, name, model): pipe = make_pipeline(MaxAbsScaler(), model) pipe(self.X_train, self.y_train) predicted = pipet(self.X_test) self_df[name + '_Pred'] = predicted score = self(self.y_test, predicted) print(f"{name} RMSE:", score) plt(figsize=(6, 4)) snst(x=predicted, y=self.y_test, scatter_kws={"s": 10}) plt('Predicted') plt('Actual') plt(f'{name} Predictions') plt(True) plt() def run_all(self): models = { 'Linear': LinearRegression(), 'MLP': MLPRegressor(random_state=42, max_iter=500, learning_rate="constant", learning_rate_init=0.6), 'DecisionTree': DecisionTreeRegressor(max_depth=15, random_state=42), 'RandomForest': RandomForestRegressor(random_state=42), 'GradientBoosting': GradientBoostingRegressor(random_state=42, learning_rate=0.6, warm_start=True), 'ExtraTrees': ExtraTreesRegressor(n_estimators=100, random_state=42) } for name, model in models(): selfsion(name, model)
Dan versi reguler tanpa __slots__.

class MachineLearning: def __init__(self, X_train, y_train, X_test, y_test): self.X_train = X_train self.y_train = y_train self.X_test = X_test self.y_test = y_test self_df = pdame({'Actual': y_test}) def rmse(self, y_true, y_pred): return mean_squared_error(y_true, y_pred, squared=False) def regression(self, name, model): pipe = make_pipeline(MaxAbsScaler(), model) pipe(self.X_train, self.y_train) predicted = pipet(self.X_test) self_df[name + '_Pred'] = predicted score = self(self.y_test, predicted) print(f"{name} RMSE:", score) plt(figsize=(6, 4)) snst(x=predicted, y=self.y_test, scatter_kws={"s": 10}) plt('Predicted') plt('Actual') plt(f'{name} Predictions') plt(True) plt() def run_all(self): models = { 'Linear': LinearRegression(), 'MLP': MLPRegressor(random_state=42, max_iter=500, learning_rate="constant", learning_rate_init=0.6), 'DecisionTree': DecisionTreeRegressor(max_depth=15, random_state=42), 'RandomForest': RandomForestRegressor(random_state=42), 'GradientBoosting': GradientBoostingRegressor(random_state=42, learning_rate=0.6, warm_start=True), 'ExtraTrees': ExtraTreesRegressor(n_estimators=100, random_state=42) } for name, model in models(): selfsion(name, model)

Perbandingan Performa: Tolok Ukur Waktu

Bandingkan kedua kelas.

import time start_normal = time() ml = MachineLearning(X_train, y_train, X_test, y_test) ml_all() end_normal = time() normal_duration = end_normal - start_normal normal_memory = ( ml.X_train.nbytes + ml.X_test.nbytes + ml.y_train.nbytes + ml.y_test.nbytes ) start_slotted = time() sml = SlottedMachineLearning(X_train, y_train, X_test, y_test) sml_all() end_slotted = time() slotted_duration = end_slotted - start_slotted slotted_memory = ( sml.X_train.nbytes + sml.X_test.nbytes + sml.y_train.nbytes + sml.y_test.nbytes ) print(f"⏱️ Durasi kelas ML normal: {normal_duration:.4f} detik") print(f"⏱️ Durasi kelas ML slotted: {slotted_duration:.4f} detik") print(f"📦 Penggunaan memori kelas ML normal: {normal_memory:.2f} bytes") print(f"📦 Penggunaan memori kelas ML slotted: {slotted_memory:.2f} bytes") time_diff = normal_duration - slotted_duration percent_faster = (time_diff / normal_duration) * 100 if percent_faster > 0: print(f"✅ Kelas ML slotted {percent_faster:.2f}% lebih cepat dari kelas ML reguler.") else: print(f"ℹ️ Tidak ada peningkatan kecepatan dengan slots dalam eksekusi ini.") memory_diff = normal_memory - slotted_memory percent_smaller = (memory_diff / normal_memory) * 100 if percent_smaller > 0: print(f"✅ Kelas ML slotted menggunakan {percent_smaller:.2f}% lebih sedikit memori dari kelas ML reguler.") else: print(f"ℹ️ Tidak ada penghematan memori dengan slots dalam eksekusi ini.")
Hasilnya menunjukkan peningkatan kecepatan yang signifikan dengan __slots__.

Kesimpulan

Dengan mencegah pembuatan __dict__ dinamis untuk setiap instance, __slots__ Python sangat baik dalam mengurangi penggunaan memori dan mempercepat akses atribut. Anda telah melihat cara kerjanya dalam praktik melalui eksplorasi data dan tugas pembelajaran mesin menggunakan proyek rekrutmen nyata Allegro. Pada dataset kecil, peningkatan mungkin kecil. Namun, seiring skala data, manfaatnya menjadi lebih terlihat, terutama dalam aplikasi yang terikat memori atau kritis performa.

Diupdate pada

2026-07-24

Kasino Olahraga d-alembert-betting-system

Keamanan data

Keamanan dimulai dengan memahami cara developer mengumpulkan dan membagikan data Anda. Praktik privasi dan keamanan data dapat bervariasi berdasarkan penggunaan, wilayah, dan usia Anda.

Tidak ada data yang dibagikan kepada pihak ketiga

Tidak ada data yang dikumpulkan

Data dienkripsi saat transit