Feature Engineering: Pengertian, Teknik, hingga Penerapannya dalam Machine Learning dengan Python

Assalamu‘alaikum wr. wb.

Halo gais! Dalam Machine Learning dan NLP, kita juga mengenal yang namanya Feature Engineering untuk menciptakan Fitur baru atau memodifikasi Fitur yang sudah ada. Feature Engineering juga melakukan seperti Penanganan Data yang Hilang, Penanganan Variabel Kategorikal, Scaling dan Normalisasi, Membuat Interaksi dan Transformasi Variabel, hingga Binning atau Diskritisasi. Lalu, apa itu Feature Engineering? Mari kita bahas pada Postingan Artikel ini!

Sumber Materi : Learndatasci.com, Turing.com, Analytics Vidhya (Blog), dan Towardsdatascience.com (Medium.com)

Konsep Machine Learning Tradisional digunakan untuk berbagai tujuan dalam banyak bisnis saat ini. Proses ini biasanya melibatkan pengumpulan dan penyimpanan data, persiapannya, dan pemanfaatannya untuk melatih model machine learning. Model-model ini memungkinkan prediksi regresi, klasifikasi, atau pengelompokan.

Selain itu, mereka digunakan untuk membangun model deep learning yang kompleks yang secara khusus fokus pada Natural Language Processing (NLP) atau Image Processing. Namun, akurasi dari model-model ini bergantung pada kualitas data yang digunakan.

Dalam artikel ini, kita akan menjelajahi konsep rekayasa fitur dan melihat bagaimana ini membantu meningkatkan kinerja dan akurasi model. Rekayasa fitur melibatkan penyintesisan data mentah untuk memberikan wawasan yang lebih berharga bagi model machine learning kita. Artikel ini akan menunjukkan bagaimana menggunakan bahasa pemrograman Python untuk melaksanakan konsep rekayasa fitur.

A. Pengertian Feature Engineering

Rekayasa Fitur atau Feature Engineering adalah proses mengubah fitur yang dipilih dalam sebuah dataset untuk menciptakan pola tertentu, memberikan wawasan, dan meningkatkan pemahaman tentang data. Ini pada akhirnya akan meningkatkan akurasi model ketika dilatih dengan data.

Fitur adalah properti atau karakteristik unik dari catatan tertentu dalam sebuah dataset. Dengan melakukan metode rekayasa, yang melibatkan manipulasi, pembersihan, dan transformasi data, ini memberikan pemahaman yang lebih baik tentang dataset secara keseluruhan.

Proses Feature Engineering dilakukan oleh analis dan/atau ilmuwan data. Ini dilakukan karena data mentah tidak sangat berguna dalam menciptakan model machine learning karena nilai yang hilang, informasi yang inkonsisten, atau tidak relevan, dll.

Biarkan saya menjelaskan - katakanlah Anda seorang barman dan seseorang datang kepada Anda dan memesan vodka tonik. Anda kemudian meminta ID dan melihat ulang tahun orang tersebut adalah "09/12/1998". Informasi ini tidak secara inheren bermakna, tetapi Anda menambahkan jumlah tahun dengan melakukan beberapa perhitungan cepat dan mengetahui bahwa orang tersebut berusia 22 tahun (yang melebihi batas usia minum legal). Apa yang terjadi di sana? Anda mengambil sepotong informasi ("09/12/1998") dan mengubahnya menjadi variabel lain (usia) untuk menjawab pertanyaan yang Anda miliki ("Apakah orang ini diizinkan minum?").

Rekayasa Fitur adalah persis seperti ini tetapi untuk Model Machine Learning. Menurut beberapa survei, Data Scientist menghabiskan waktunya untuk persiapan data. Lihat gambar di bawah ini :

Sumber : Researchgate.net

B. Alur Kerja Feature Engineering

Sumber : Learndatasci.com

Setiap Pipeline Data Science dimulai dengan Exploratory Data Analysis (EDA), atau analisis awal data kami. EDA adalah langkah pra-kursor yang sangat penting karena kami mendapatkan pemahaman yang lebih baik tentang fitur apa yang perlu kami buat/modifikasi. Langkah berikutnya biasanya adalah membersihkan data/menyelaraskan data tergantung seberapa tidak terstruktur atau berantakan data tersebut.

Feature engineering adalah langkah selanjutnya, dan kami memulai proses itu dengan mengevaluasi kinerja dasar data yang ada. Kemudian kami secara iteratif membuat fitur-fitur dan terus-menerus mengevaluasi kinerja model (dan membandingkannya dengan kinerja dasar) melalui proses yang disebut seleksi fitur, hingga kami puas dengan hasilnya.

C. Pentingnya Feature Engineering

Feature engineering memiliki peran penting dalam konsep machine learning tradisional. Berikut adalah pentingnya Feature Engineering : 

import pandas as pd
import numpy as np
from sklearn.impute import SimpleImputer

# Creating a sample dataset with missing values
data = {
    'Name': ['John', 'Alice', 'Bob', 'Emma', 'Tom'],
    'Age': [20, np.nan, 22, 19, 18],
    'TestScore': [85, 90, np.nan, 78, 92],
    'Grade': ['A', 'B', np.nan, 'C', 'A']
}

df = pd.DataFrame(data)

print("Original Dataset:")
print(df)

# 1. Using Mean/Median/Mode Imputation
imputer = SimpleImputer(strategy='mean') # Other strategies: 'median', 'most_frequent' for mode
df_imputed = pd.DataFrame(imputer.fit_transform(df[['Age', 'TestScore']]), columns=['Age', 'TestScore'])
df['Age'] = df_imputed['Age']
df['TestScore'] = df_imputed['TestScore']

print("\nAfter Mean/Median Imputation:")
print(df)

Original Dataset:
    Name   Age  TestScore Grade
0   John  20.0       85.0     A
1  Alice   NaN       90.0     B
2    Bob  22.0        NaN   NaN
3   Emma  19.0       78.0     C
4    Tom  18.0       92.0     A

After Mean/Median Imputation:
    Name    Age  TestScore Grade
0   John  20.00      85.00     A
1  Alice  19.75      90.00     B
2    Bob  22.00      86.25   NaN
3   Emma  19.00      78.00     C
4    Tom  18.00      92.00     A

import pandas as pd
import numpy as np

# Creating a sample dataset with missing values
data = {
    'Name': ['John', 'Alice', 'Bob', 'Emma', 'Tom'],
    'Age': [20, np.nan, 22, 19, 18],
    'TestScore': [85, 90, np.nan, 78, 92],
    'Grade': ['A', 'B', np.nan, 'C', 'A']
}

df = pd.DataFrame(data)

# 2. Using Forward Fill and Backward Fill (ffill, bfill)
df_ffill = df.fillna(method='ffill')
df_bfill = df.fillna(method='bfill')

print("\nAfter Forward Fill:")
print(df_ffill)

print("\nAfter Backward Fill:")
print(df_bfill)

After Forward Fill:
    Name   Age  TestScore Grade
0   John  20.0       85.0     A
1  Alice  20.0       90.0     B
2    Bob  22.0       90.0     B
3   Emma  19.0       78.0     C
4    Tom  18.0       92.0     A

After Backward Fill:
    Name   Age  TestScore Grade
0   John  20.0       85.0     A
1  Alice  22.0       90.0     B
2    Bob  22.0       78.0     C
3   Emma  19.0       78.0     C
4    Tom  18.0       92.0     A

import pandas as pd
import numpy as np

# Creating a sample dataset with missing values
data = {
    'Name': ['John', 'Alice', 'Bob', 'Emma', 'Tom'],
    'Age': [20, np.nan, 22, 19, 18],
    'TestScore': [85, 90, np.nan, 78, 92],
    'Grade': ['A', 'B', np.nan, 'C', 'A']
}

df = pd.DataFrame(data)
print(df)

# 3. Using Interpolation
df_interpolated = df.interpolate()
print("\nAfter Interpolation:")
print(df_interpolated)

    Name   Age  TestScore Grade
0   John  20.0       85.0     A
1  Alice   NaN       90.0     B
2    Bob  22.0        NaN   NaN
3   Emma  19.0       78.0     C
4    Tom  18.0       92.0     A

After Interpolation:
    Name   Age  TestScore Grade
0   John  20.0       85.0     A
1  Alice  21.0       90.0     B
2    Bob  22.0       84.0   NaN
3   Emma  19.0       78.0     C
4    Tom  18.0       92.0     A

import pandas as pd
import numpy as np
from sklearn.impute import KNNImputer # Import the correct class for KNN imputation

# Creating a sample dataset with missing values
data = {
    'Name': ['John', 'Alice', 'Bob', 'Emma', 'Tom'],
    'Age': [20, np.nan, 22, 19, 18],
    'TestScore': [85, 90, np.nan, 78, 92],
    'Grade': ['A', 'B', np.nan, 'C', 'A']
}

df = pd. DataFrame(data)
print(df)

# 4. Using K-Nearest Neighbors (KNN) Imputation
#Using K-Nearest Neighbors (KNN) Imputation for 'Age' column
knn_imputer_age = KNNImputer(n_neighbors=2)
df ['Age'] = knn_imputer_age.fit_transform(df[['Age']]) # Fit and transform for 'Age' column

#Using K-Nearest Neighbors (KNN) Imputation for 'TestScore' column
knn_imputer_testscore = KNNImputer(n_neighbors=2)
df['TestScore'] = knn_imputer_testscore.fit_transform(df[['TestScore']]) # Fit and transform for 'TestScore' column

print("\nAfter KNN Imputation:")
print(df)

    Name   Age  TestScore Grade
0   John  20.0       85.0     A
1  Alice   NaN       90.0     B
2    Bob  22.0        NaN   NaN
3   Emma  19.0       78.0     C
4    Tom  18.0       92.0     A

After KNN Imputation:
    Name    Age  TestScore Grade
0   John  20.00      85.00     A
1  Alice  19.75      90.00     B
2    Bob  22.00      86.25   NaN
3   Emma  19.00      78.00     C
4    Tom  18.00      92.00     A

import pandas as pd
from sklearn.preprocessing import OneHotEncoder, LabelEncoder

# Creating a sample dataset with categorical data
data = {
    'Fruit': ['Apple', 'Banana', 'Orange', 'Apple', 'Banana'],
    'Color': ['Red', 'Yellow', 'Orange', 'Green', 'Yellow']
}

df = pd. DataFrame(data)

print("Original Dataset:")
print(df)

# 1. One-Hot Encoding
one_hot_encoder = OneHotEncoder(sparse_output=False, drop='first') # Drop first category to avoid multicollinearity
one_hot_encoded = one_hot_encoder.fit_transform(df[['Fruit', 'Color']])
feature_names = one_hot_encoder.get_feature_names_out(['Fruit', 'Color'])
df_one_hot = pd.DataFrame(one_hot_encoded, columns=feature_names)

# Concatenate the encoded DataFrame with the original DataFrame
df_encoded = pd.concat([df.drop(['Fruit', 'Color'], axis=1), df_one_hot], axis=1)

print("\nAfter One-Hot Encoding:")
print(df_encoded)

Original Dataset:
    Fruit   Color
0   Apple     Red
1  Banana  Yellow
2  Orange  Orange
3   Apple   Green
4  Banana  Yellow

After One-Hot Encoding:
   Fruit_Banana  Fruit_Orange  Color_Orange  Color_Red  Color_Yellow
0           0.0           0.0           0.0        1.0           0.0
1           1.0           0.0           0.0        0.0           1.0
2           0.0           1.0           1.0        0.0           0.0
3           0.0           0.0           0.0        0.0           0.0
4           1.0           0.0           0.0        0.0           1.0

import pandas as pd
from sklearn.preprocessing import OneHotEncoder, LabelEncoder

# Creating a sample dataset with categorical data
data = {
'Fruit': ['Apple', 'Banana', 'Orange', 'Apple', 'Banana'],
'Color': ['Red', 'Yellow', 'Orange', 'Green', 'Yellow']
}

df = pd.DataFrame(data)

print("Original Dataset:")
print(df)

# 2. Label Encoding
label_encoder = LabelEncoder()
df_label_encoded = df.copy ()
df_label_encoded['Fruit'] = label_encoder.fit_transform(df['Fruit'])
df_label_encoded['Color'] = label_encoder.fit_transform(df['Color'])

print("\nAfter Label Encoding:")
print(df_label_encoded)

Original Dataset:
    Fruit   Color
0   Apple     Red
1  Banana  Yellow
2  Orange  Orange
3   Apple   Green
4  Banana  Yellow

After Label Encoding:
   Fruit  Color
0      0      2
1      1      3
2      2      1
3      0      0
4      1      3

import pandas as pd
from category_encoders import TargetEncoder
from sklearn.preprocessing import LabelEncoder

# Creating a sample dataset with categorical data
data = {
    'Fruit': ['Apple', 'Banana', 'Orange', 'Apple', 'Banana'],
    'Color': ['Red', 'Yellow', 'Orange', 'Green', 'Yellow']
}

df = pd.DataFrame(data)

print("Original Dataset:")
print(df)

# Convert the target variable 'Fruit' to numeric using LabelEncoder
label_encoder = LabelEncoder()
df['Fruit'] = label_encoder.fit_transform(df ['Fruit'])

# 3. Target Encoding
target_encoder = TargetEncoder()
df_target_encoded = df.copy()
df_target_encoded[['Fruit', 'Color']] = target_encoder.fit_transform(df[['Fruit', 'Color']], df['Fruit'])

print("\nAfter Target Encoding:")
print(df_target_encoded)

Original Dataset:
    Fruit   Color
0   Apple     Red
1  Banana  Yellow
2  Orange  Orange
3   Apple   Green
4  Banana  Yellow

After Target Encoding:
   Fruit     Color
0      0  0.695913
1      1  0.828370
2      2  0.956130
3      0  0.695913
4      1  0.828370

!pip install category_encoders

import pandas as pd
from sklearn.preprocessing import MinMaxScaler

# Creating a sample dataset with numerical features
data = {
    'Age': [20, 25, 18, 22, 30],
    'TestScore': [85, 90, 78, 92, 88],
    'Grade': [90, 85, 70, 95, 80]
}
df = pd. DataFrame(data)

print("Original Dataset:")
print(df)

# 1. Min-Max Scaling (Normalization)
min_max_scaler = MinMaxScaler()
df_normalized = min_max_scaler.fit_transform(df)
df_normalized = pd. DataFrame(df_normalized, columns=df.columns)

print("\nAfter Min-Max Scaling (Normalization):")
print(df_normalized)

Original Dataset:
   Age  TestScore  Grade
0   20         85     90
1   25         90     85
2   18         78     70
3   22         92     95
4   30         88     80

After Min-Max Scaling (Normalization):
        Age  TestScore  Grade
0  0.166667   0.500000    0.8
1  0.583333   0.857143    0.6
2  0.000000   0.000000    0.0
3  0.333333   1.000000    1.0
4  1.000000   0.714286    0.4

Kita menggunakan MinMaxScaler dari Scikit-learn untuk menyesuaikan skala fitur ke rentang tertentu (biasanya [0, 1]). Transformasi ini mempertahankan distribusi asli data dan cocok ketika data memiliki rentang terbatas.

• Standardisasi : Standardisasi mengubah fitur-fitur dalam dataset dengan menggunakan rata-rata dan deviasi standar. Nilai rata-ratanya adalah 0 dan deviasi standarnya adalah 1.

Kode Program :

import pandas as pd
from sklearn.preprocessing import StandardScaler

# Creating a sample dataset with numerical features
data = {
    'Age': [20, 25, 18, 22, 30],
    'TestScore': [85, 90, 78, 92, 88],
    'Grade': [90, 85, 70, 95, 80]
}

df = pd. DataFrame(data)

print("Original Dataset:")
print (df)

# 2. Standardization
standard_scaler = StandardScaler()
df_standardized = standard_scaler.fit_transform(df)
df_standardized = pd.DataFrame(df_standardized, columns=df.columns)

print("\nAfter Standardization:")
print(df_standardized)

Output :

Original Dataset:
   Age  TestScore  Grade
0   20         85     90
1   25         90     85
2   18         78     70
3   22         92     95
4   30         88     80

After Standardization:
        Age  TestScore     Grade
0 -0.715097  -0.327693  0.697486
1  0.476731   0.696347  0.116248
2 -1.191828  -1.761349 -1.627467
3 -0.238366   1.105963  1.278724
4  1.668560   0.286731 -0.464991

Kami menggunakan StandardScaler dari Scikit-learn untuk menyesuaikan skala fitur sehingga memiliki rata-rata 0 dan deviasi standar 1. Teknik ini berguna ketika data memiliki pencilan atau distribusi yang tidak normal.

4. Membuat Fitur Polinomial

​Membuat fitur polinomial adalah metode lain dari rekayasa fitur. Ini memberikan kekuatan pada fitur yang ada untuk membuat fitur polinomial.

Mari kita pertimbangkan satu set data yang berisi informasi tentang rumah, termasuk luasnya dan harga jualnya. Kami akan menunjukkan bagaimana membuat fitur polinomial untuk menangkap hubungan non-linear antara luas rumah dan harga jualnya.

• Fitur Polinomial dalam Python : Ini adalah fitur yang dibuat dari fitur yang ada dalam satu set data. Fitur polinomial dapat berupa pangkat n. Di mana n adalah angka yang mewakili pangkat eksponensial.

Kode Program :

import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression

# Creating a sample dataset with non-linear relationship
data = {
    'Area': [1000, 1500, 2000, 2500, 3000],
    'SalePrice': [300000, 450000, 550000, 650000, 800000]
}

df = pd.DataFrame(data)

print("Original Dataset:")
print(df)

# 1. PolynomialFeatures in Python
# Let's create polynomial features to capture the non-linear relationship between 'Area' and 'SalePrice'.
degree = 2  # The degree of the polynomial features (2 for quadratic)
poly_features = PolynomialFeatures(degree=degree, include_bias=False)
X_poly = poly_features.fit_transform(df[['Area']])
df_poly = pd.DataFrame(X_poly, columns=[f'Area^{i}' for i in range(1, degree + 1)])
df_poly['SalePrice'] = df['SalePrice']

print("\nAfter Creating Polynomial Features:")
print(df_poly)

# Fit a linear regression model to the polynomial features
X = df_poly.drop('SalePrice', axis=1)
y = df_poly['SalePrice']

linear_regression = LinearRegression()
linear_regression.fit(X, y)  # Use X instead of x

# Predict the sale prices using the linear regression model
predicted_prices = linear_regression.predict(X)
df_poly['PredictedPrice'] = predicted_prices

print("\nPredicted Sale Prices:")
print(df_poly[['SalePrice', 'PredictedPrice']])

Output :

Original Dataset:
   Area  SalePrice
0  1000     300000
1  1500     450000
2  2000     550000
3  2500     650000
4  3000     800000

After Creating Polynomial Features:
   Area^1     Area^2  SalePrice
0  1000.0  1000000.0     300000
1  1500.0  2250000.0     450000
2  2000.0  4000000.0     550000
3  2500.0  6250000.0     650000
4  3000.0  9000000.0     800000

Predicted Sale Prices:
   SalePrice  PredictedPrice
0     300000        310000.0
1     450000        430000.0
2     550000        550000.0
3     650000        670000.0
4     800000        790000.0

Pada contoh ini, kita membuat satu set data contoh dengan 'Area' rumah dan 'SalePrice' yang sesuai. Kemudian, kami menggunakan PolynomialFeatures dari Scikit-learn untuk membuat fitur polinomial yang menangkap hubungan non-linear antara 'Area' dan 'SalePrice'. Kami memilih derajat 2 (kuadrat) untuk membuat fitur polinomial hingga kuadrat dari 'Area'.

Fitur polinomial membantu menangkap pola non-linear dalam data, dan kemudian kami menggunakan regresi linear untuk mencocokkan model ke fitur-fitur ini. Model sekarang dapat memprediksi harga jual rumah berdasarkan luasnya, dengan memperhitungkan hubungan non-linear.

5. Feature Selection

Pemilihan Fitur adalah teknik rekayasa fitur yang memilih hanya fitur-fitur yang dominan atau relevan dalam sebuah dataset. Ini menggunakan algoritma untuk menentukan fitur-fitur mana yang memiliki dampak atau hubungan paling besar dengan variabel target. Ketika model dilatih hanya dengan fitur-fitur yang relevan terpilih, ini dapat meningkatkan akurasi model pembelajaran mesin.

Mari pertimbangkan dataset yang berisi informasi tentang kinerja siswa, termasuk jam belajar, nilai ujian, nilai, dan partisipasi dalam kegiatan ekstrakurikuler. Kami akan menunjukkan dua teknik pemilihan fitur: Pemilihan Fitur Univariat, dan Regularisasi L1 (Lasso).

• Pemilihan Fitur Univariat : Pemilihan fitur univariat menghapus semua fitur yang variansanya tidak memenuhi nilai ambang tertentu.

Kode Program :

import pandas as pd
import numpy as np
from sklearn.datasets import make_regression
from sklearn.feature_selection import SelectKBest, f_regression
from sklearn.linear_model import Lasso

# Generating a sample dataset with synthetic features and target
X, y = make_regression(n_samples=100, n_features=10, random_state=42)

# Creating a DataFrame from the generated data
df = pd.DataFrame(X, columns=[f'Feature_{i}' for i in range(1, 11)])
df['Target'] = y

print("Original Dataset:")
print (df.head())

# 1. Univariate Feature Selection
k_best = 5 # Select the top 5 features
selector = SelectKBest(score_func=f_regression, k=k_best)
X_univariate = selector.fit_transform(X, y)
selected_features_univariate = df.columns [:-1] [selector. get_support()]

print("\nSelected Features using Univariate Feature Selection:")
print (selected_features_univariate)

Output :

Original Dataset:
   Feature_1  Feature_2  Feature_3  Feature_4  Feature_5  Feature_6  \
0   0.150394   0.950424  -0.759133  -2.123896  -0.576904  -0.599393   
1   1.088951  -0.715304  -0.471932   0.686260   0.679598  -1.867265   
2  -0.714351  -1.191303   0.293072  -0.680025   0.656554   0.346448   
3   0.404051   0.257550  -0.161286  -0.342715  -0.074446  -0.420645   
4   0.606010  -2.081929  -1.556629  -0.704344   1.696456   1.049009   

   Feature_7  Feature_8  Feature_9  Feature_10     Target  
0  -0.525755  -0.839722   0.341756    1.876171 -60.486955  
1  -1.612716   2.314659   0.064280   -1.077745  -0.091994  
2   0.232254   0.250493   1.865775    0.473833 -76.947132  
3  -0.802277  -1.415371   1.886186    0.174578 -38.245170  
4  -1.408461  -0.522723  -1.280429    1.754794  -1.831243  

Selected Features using Univariate Feature Selection:
Index(['Feature_1', 'Feature_2', 'Feature_4', 'Feature_5', 'Feature_7'], dtype='object')

Kami menggunakan SelectKBest dari Scikit-learn untuk memilih k fitur teratas berdasarkan relevansinya dengan variabel target menggunakan fungsi skor f_regression.

• Regularisasi L1 (Lasso) : Algoritma regresi Lasso dapat mengurangi koefisien dan menghapus yang memiliki nilai lebih rendah.

import pandas as pd
import numpy as np
from sklearn.datasets import make_regression
from sklearn.feature_selection import SelectKBest
from sklearn.linear_model import Lasso

# Generating a sample dataset with synthetic features and target
x, y = make_regression(n_samples=100, n_features=10, random_state=42)

# Creating a DataFrame from the generated data
df = pd.DataFrame(X, columns=[f'Feature_{i}' for i in range(1, 11)])
df['Target'] = y

print("Original Dataset:")
print(df.head())

# 2. L1 Regularization (Lasso)
k_best = 5 # Select the top 5 features
lasso = Lasso(alpha=0.1) # Adjust the regularization strength (alpha) as needed
lasso.fit(x, y)
coefficients = np.abs(lasso.coef_)
selected_features_lasso = df.columns [:-1] [np.argsort (coefficients) [::-1] ] [:k_best]

print("\nSelected Features using L1 Regularization (Lasso):")
print(selected_features_lasso)

Output :

Original Dataset:
   Feature_1  Feature_2  Feature_3  Feature_4  Feature_5  Feature_6  \
0   0.150394   0.950424  -0.759133  -2.123896  -0.576904  -0.599393   
1   1.088951  -0.715304  -0.471932   0.686260   0.679598  -1.867265   
2  -0.714351  -1.191303   0.293072  -0.680025   0.656554   0.346448   
3   0.404051   0.257550  -0.161286  -0.342715  -0.074446  -0.420645   
4   0.606010  -2.081929  -1.556629  -0.704344   1.696456   1.049009   

   Feature_7  Feature_8  Feature_9  Feature_10     Target  
0  -0.525755  -0.839722   0.341756    1.876171 -60.486955  
1  -1.612716   2.314659   0.064280   -1.077745  -0.091994  
2   0.232254   0.250493   1.865775    0.473833 -76.947132  
3  -0.802277  -1.415371   1.886186    0.174578 -38.245170  
4  -1.408461  -0.522723  -1.280429    1.754794  -1.831243  

Selected Features using L1 Regularization (Lasso):
Index(['Feature_1', 'Feature_5', 'Feature_2', 'Feature_7', 'Feature_4'], dtype='object')

Kami menggunakan regresi Lasso, yang menerapkan regularisasi L1, untuk menghukum fitur-fitur yang memiliki tingkat kepentingan rendah dengan menaikkan koefisiennya ke nol. Kami memilih k fitur teratas dengan koefisien absolut tertinggi.

Itulah Teknik Dimensionality Reduction dalam Python dalam Machine Learning (ML). Mohon maaf apabila ada kesalahan apapun.

Terima Kasih 😄😘👌👍 :)

Wassalamu‘alaikum wr. wb.