Sybil Detection with Human Passport and Octant
Participant: Mahboob Biswas 
Email : mahboobbiswas@gmail.com
Contact : +91 7029232633
Date: May 31, 2025
Write-Up for is for my 11th submission.
End-to-End Write-Up for Sybil Detection Model
This write-up provides a comprehensive overview of the Sybil detection model implemented in the sybil_detection.ipynb Jupyter Notebook. The model aims to predict the probability (0 to 1) of a wallet address being a Sybil (a malicious entity creating multiple identities to manipulate a system) using blockchain data. The notebook employs advanced machine learning techniques, including feature engineering, class imbalance handling, hyperparameter tuning, ensemble methods, and model evaluation, to achieve high performance. Below, we explain each cell, its purpose, expected functionality, and anticipated outputs before building the model, followed by a summary of the overall pipeline.
Overview
Purpose: This cell provides an introduction to the Sybil detection model, outlining its objectives and the improvements implemented to enhance performance.
Content:
- Objective: Predict the probability that a wallet address is a Sybil using historical blockchain data.
- Improvements:
- Address overfitting with cross-validation and regularization.
- Enhance model performance through hyperparameter tuning, SMOTE for class imbalance, and threshold optimization.
- Analyze feature importance using model-based metrics and SHAP (SHapley Additive exPlanations).
- Implement ensemble methods like stacking, LightGBM, CatBoost, and voting classifiers.
Import Libraries
Purpose: Import all necessary Python libraries for data processing, modeling, evaluation, and visualization.
Functionality:
- Imports libraries for:
- Data manipulation (
numpy, pandas).
- Machine learning models (
xgboost, lightgbm, catboost, sklearn).
- Visualization (
matplotlib, seaborn).
- Model evaluation (
sklearn.metrics).
- Class imbalance handling (
imblearn.over_sampling.SMOTE).
- Feature importance analysis (
shap).
- Utility (
os, joblib, datetime, warnings).
- Suppresses warnings to keep the output clean.
Data Loading
Purpose: Load the blockchain datasets (transactions, DEX swaps, token transfers, and address labels) for training and testing.
Functionality:
- Sets a random seed (
np.random.seed(42)) for reproducibility.
- Loads parquet files containing:
- Test addresses:
test_addresses_base, test_addresses_ethereum (contain ADDRESS column).
- Train addresses:
train_addresses_base, train_addresses_ethereum (contain ADDRESS and LABEL columns).
- Feature datasets: Transactions, DEX swaps, and token transfers for both Base and Ethereum chains.
- Prints dataset information and column names to inspect the data structure.
Feature Engineering
Purpose: Create features from raw blockchain data to capture patterns indicative of Sybil behavior.
Functionality:
- Defines a function
prepare_data_for_xgboost that:
- Creates a feature DataFrame indexed by unique addresses.
- Generates transaction-based features: Count, mean value, mean fee, and standard deviation of gas used.
- Generates temporal features: Transaction time span (days) and frequency per day.
- Generates swap-based features: Count, mean amounts in/out, and standard deviation of amount out.
- Generates interaction features: Ratios of fees to value and swap in/out amounts.
- Generates transfer-based features: Count and mean amount.
- Creates categorical features: One-hot encoded counts of swap platforms (e.g.,
platform_uniswap-v3).
- Fills missing values with medians and scales numerical features using
StandardScaler.
- For training, joins labels and returns features (
X) and labels (y); for testing, returns features only.
- Combines Base and Ethereum data for training and test sets.
- Saves the feature order to
xgb_feature_order.csv for consistency.
Handle Class Imbalance with SMOTE
Purpose: Address the imbalance between Sybil (minority) and non-Sybil (majority) classes using SMOTE (Synthetic Minority Oversampling Technique).
Functionality:
-
Converts labels to numeric, fills NaN with 0, and binarizes them (threshold 0.5).
-
Applies SMOTE to oversample the minority class (Sybil, label 1) to match the majority class (non-Sybil, label 0).
-
Prints the original and resampled class distributions.
Original class distribution: {0: 99985, 1: 4031}
Resampled class distribution: {0: 99985, 1: 99985}
Train-Test Split
Purpose: Split the resampled data into training and validation sets.
Functionality:
-
Splits X_resampled and y_resampled into 80% training (X_train, y_train) and 20% validation (X_val, y_val) sets.
-
Uses stratify=y_resampled to maintain class balance.
-
Prints the shapes of the resulting datasets.
-
Example output:
Training set shape: (159976, 44), Validation set shape: (39994, 44)
-
The data is split, with balanced classes in both sets, ready for model training.
Hyperparameter Tuning for XGBoost
Purpose: Optimize the XGBoost model’s hyperparameters using grid search to maximize ROC-AUC.
Code Cell:
xgb_param_grid = {
'max_depth': [3, 5, 7],
'n_estimators': [100, 200],
'learning_rate': [0.01, 0.1],
'subsample': [0.8, 1.0],
'colsample_bytree': [0.8, 1.0],
'lambda': [1, 2],
'alpha': [0, 1]
}
Functionality:
- Defines a hyperparameter grid for XGBoost, testing various combinations of depth, estimators, learning rate, subsampling, and regularization parameters.
- Initializes an
XGBClassifier with class weights to handle any residual imbalance.
- Performs 3-fold cross-validated grid search to maximize ROC-AUC.
- Fits the model on
X_train, y_train.
- Prints the best parameters and ROC-AUC score.
- Example output:
Best XGBoost Parameters: {'alpha': 0, 'colsample_bytree': 1.0, 'lambda': 1, 'learning_rate': 0.1, 'max_depth': 7, 'n_estimators': 200, 'subsample': 0.8}
Best XGBoost ROC-AUC: 0.9992139265200622
best_xgb contains the optimized XGBoost model, ready for ensemble methods.
Train Other Models
Purpose: Train additional models (Random Forest, LightGBM, CatBoost) with basic hyperparameters for ensemble methods.
Code Cell:
rf_model = RandomForestClassifier(
n_estimators=200,
max_depth=10,
class_weight='balanced',
random_state=42,
n_jobs=-1
)
rf_model.fit(X_train, y_train)
lgb_model = lgb.LGBMClassifier(
n_estimators=200,
max_depth=7,
learning_rate=0.1,
is_unbalance=True,
random_state=42,
verbose=-1
)
lgb_model.fit(X_train, y_train)
cb_model = cb.CatBoostClassifier(
iterations=200,
depth=7,
learning_rate=0.1,
auto_class_weights='Balanced',
verbose=0,
random_state=42
)
Functionality:
- Trains a Random Forest with 200 trees, max depth 10, and balanced class weights.
- Trains a LightGBM model with 200 estimators, max depth 7, and imbalance handling.
- Trains a CatBoost model with 200 iterations, depth 7, and balanced class weights.
- Fits all models on
X_train, y_train.
Ensemble Methods
Purpose: Implement stacking and voting classifiers to combine predictions from XGBoost, Random Forest, LightGBM, and CatBoost.
Code Cell:
stacking_model = StackingClassifier(
estimators=[
('xgb', best_xgb),
('rf', rf_model),
('lgb', lgb_model),
('cb', cb_model)
],
final_estimator=LogisticRegression(),
cv=3
)
stacking_model.fit(X_train, y_train)
voting_model = VotingClassifier(
estimators=[
('xgb', best_xgb),
('rf', rf_model),
('lgb', lgb_model),
('cb', cb_model)
],
voting='soft'
)
Functionality:
- Stacking Classifier:
- Combines predictions from XGBoost, Random Forest, LightGBM, and CatBoost using 3-fold cross-validation.
- Uses Logistic Regression as the final estimator to make the final prediction.
- Voting Classifier:
- Combines predictions using soft voting (averaging probabilities).
- Fits both models on
X_train, y_train.
Model Evaluation
Purpose: Evaluate the stacking model on the validation set, optimize the classification threshold, and report performance metrics.
Functionality:
- Computes predicted probabilities for the validation set using the stacking model.
- Calculates precision, recall, and F1-scores for various thresholds.
- Selects the threshold that maximizes the F1-score.
- Generates binary predictions using the best threshold.
- Prints the classification report (precision, recall, F1-score per class) and ROC-AUC score.
Output:
- Best Threshold: A value, e.g.,
0.5000, optimized for F1-score.
- Classification Report: Metrics for classes 0 and 1, e.g.:
precision recall f1-score support
0 0.99 0.99 0.99 19997
1 0.99 0.99 0.99 19997
accuracy 0.99 39994
macro avg 0.99 0.99 0.99 39994
weighted avg 0.99 0.99 0.99 39994
- Validation ROC-AUC: A high score, e.g.,
0.9994, indicating excellent discriminative ability.
- Example output:
Best threshold: 0.5000
precision recall f1-score support
0 0.99 0.99 0.99 19997
1 0.99 0.99 0.99 19997
accuracy 0.99 39994
macro avg 0.99 0.99 0.99 39994
weighted avg 0.99 0.99 0.99 39994
Validation ROC-AUC: 0.9994
- The model’s performance is evaluated, and the optimal threshold is identified.
Feature Importance Analysis
Purpose: Analyze feature importance using XGBoost’s built-in importance scores and SHAP values.
Functionality:
-
Creates a DataFrame of feature importances from the XGBoost model.
-
Plots a bar chart of the top 20 features using Seaborn.
-
Prints the top 20 features with their importance scores.
-
Uses SHAP to compute and visualize feature contributions for the validation set.
-
Output: A DataFrame listing the top 20 features, we are including only 10 e.g.:
Top 20 Features:
feature importance
0 tx_time_span_days 0.1500
1 platform_hashflow-v3 0.1200
2 tx_count 0.1000
3 tx_gas_used_std 0.068686
4 transfer_count 0.032816
5 tx_freq_per_day 0.019382
6 tx_gas_used_std 0.068686
7 swap_amount_out_usd_mean 0.011656
8 transfer_amount_usd_mean 0.029811
9 tx_value_usd_mean 0.032430
10 tx_fee_mean 0.054944
...
-
SHAP Plot: A bar plot showing SHAP values for the top 20 features, highlighting their impact on predictions.
-
The analysis identifies key features driving Sybil detection, such as temporal and platform-specific behaviors.
Cross-Validation
Purpose: Perform 5-fold cross-validation to assess the stacking model’s robustness.
Code Cell:
Functionality:
-
Performs 5-fold stratified cross-validation on the resampled data.
-
Trains the stacking model on each fold and computes ROC-AUC on the validation fold.
-
Prints the ROC-AUC scores for each fold, along with the mean and standard deviation.
-
Output:
Cross-Validation ROC-AUC Scores: [0.9989968553291696, 0.9990570846466095, 0.9983119511233182, 0.9990006602205515, 0.9990545813956908]
Mean CV ROC-AUC: 0.9989, Std: 0.0003
-
The cross-validation confirms the model’s robustness across different data splits.
Generate Test Predictions
Purpose: Generate predictions for the test set and create a submission file.
Functionality:
-
Defines a function prepare_test_submission that:
- Combines test addresses from Base and Ethereum datasets, ensuring uniqueness.
- Aligns test features with the training feature order (
xgb_feature_order.csv).
- Removes duplicate indices and reindexes to match test addresses.
- Fills missing values with medians.
- Predicts probabilities and binary classes using the stacking model and optimized threshold.
- Creates a submission DataFrame with
ADDRESS and PRED (probabilities).
- Saves the submission to
submission_improved.csv.
-
Calls the function and prints the first five rows of the submission.
-
A file submission_improved.csv is created with unique 20,369 rows, containing addresses and their predicted Sybil probabilities.
Conclusion
Purpose: Summarize the model’s performance and suggest future enhancements.
Content:
- Reports a validation ROC-AUC of 0.9994 (XGBoost) and F1-score of 0.9940 (stacking model).
- Highlights key factors: SMOTE, robust feature engineering (temporal and platform features), ensemble methods, and overfitting prevention.
- Notes important features:
tx_time_span_days, platform_hashflow-v3.
Next write up 
Write-Up for is for my 12th submission.
The sybil-v2.ipynb.zip Jupyter Notebook implements an enhanced machine learning pipeline for Sybil detection in a blockchain context, as part of a competition by Human Passport by Holonym, Octant, and the Ethereum Foundation. The goal is to predict the probability (0 to 1) of a wallet address being a Sybil (fake identity) using historical blockchain data. This write-up provides a comprehensive overview of the model, explaining each cell, outputs, techniques used, and performance metrics, aligning with the outcomes before building the model.
Overview of the Notebook and Objectives
The notebook builds on my previous Sybil detection model by incorporating graph-based features and dynamic thresholding to improve detection capabilities. Sybil detection in blockchain involves identifying fake wallet addresses used to manipulate systems (e.g., airdrops, voting). The model processes blockchain transaction data, extracts features, handles class imbalance, trains multiple models, and uses an ensemble approach to generate predictions.
Objectives
- Predict the probability (0 to 1) of a wallet being a Sybil.
- Enhance feature engineering with graph-based features to capture wallet relationships.
- Implement dynamic thresholding to optimize for multiple metrics (F1-Score, recall, precision-recall AUC).
- Achieve high ROC-AUC, F1-Score, and recall while minimizing overfitting.
Explanation and Outputs
Import Libraries
- Purpose: Imports necessary libraries for data processing, modeling, evaluation, visualization, and graph analysis.
- Key Libraries:
- Data Processing:
pandas, numpy.
- Models:
xgboost, lightgbm, catboost, sklearn (Random Forest, Logistic Regression).
- Evaluation:
sklearn.metrics (ROC-AUC, F1-Score, etc.).
- Graph Analysis:
networkx.
- Visualization:
matplotlib, seaborn, shap.
- Imbalance Handling:
imblearn (SMOTE).
Data Loading
- Purpose: Loads blockchain datasets and preprocesses the
LABEL column in training data to ensure binary labels (0 or 1).
- Datasets:
test_addresses_base, test_addresses_ethereum: Test wallet addresses (ADDRESS).train_addresses_base, train_addresses_ethereum: Training wallet addresses (ADDRESS, LABEL).dex_swaps_base, dex_swaps_ethereum: Swap transactions.token_transfers_base, token_transfers_ethereum: Token transfers.transactions_base, transactions_ethereum: Transaction data.
- Preprocessing:
- Converts
LABEL to numeric, coercing invalid entries to NaN.
- Binarizes
LABEL using a 0.5 threshold (≥ 0.5 → 1, else 0).
-
20,369 test addresses, as expected for a competition dataset.
-
51,515 training addresses, with LABEL initially as object (preprocessed to int).
- DEX Swaps Base Columns:
['BLOCK_NUMBER', 'BLOCK_TIMESTAMP', 'TX_HASH', ...] (25 columns).
- Token Transfers Base Columns:
['BLOCK_NUMBER', 'BLOCK_TIMESTAMP', 'TX_HASH', ...] (18 columns).
- Transactions Base Columns:
['BLOCK_NUMBER', 'BLOCK_TIMESTAMP', 'TX_HASH', ...] (30 columns).
Feature Engineering Overview
- Purpose: Extracts features from blockchain data, including transaction-based, temporal, swap-based, transfer-based, categorical, and graph-based features.
- Function:
prepare_data_for_xgboost(data, is_train=True)
- Inputs:
data: Dictionary with transactions, dex_swaps, token_transfers, train_addresses/test_addresses.is_train: Boolean indicating training (returns features and labels) or testing (features only).
- Steps:
- Transaction Features:
tx_count, tx_value_usd_mean, tx_fee_mean, tx_gas_used_std.
- Temporal Features:
tx_time_span_days, tx_freq_per_day.
- Swap Features:
swap_count, swap_amount_in_usd_mean, swap_amount_out_usd_mean, swap_amount_out_usd_std.
- Interaction Features:
tx_fee_to_value_ratio, swap_in_out_ratio.
- Transfer Features:
transfer_count, transfer_amount_usd_mean.
- Categorical Features: One-hot encodes
PLATFORM (e.g., platform_hashflow-v3).
- Graph-Based Features (Optimized):
- Samples 100,000 rows from
transactions and transfers to reduce graph size.
- Computes
in_degree and out_degree directly from edge lists.
- Builds a sampled graph and subgraph (top 10,000 nodes by degree).
- Computes
clustering_coefficient and betweenness_centrality on the subgraph.
- Preprocessing: Fills missing values with medians, scales features with
StandardScaler.
- Output:
- For training: Features
X (DataFrame), labels y (Series).
- For testing: Features
X only.
- Execution:
- Processes training and test data, saving feature order to
xgb_feature_order.csv.
- Prints:
Warning: Duplicate addresses found in addresses DataFrame. Dropping duplicates.
- Indicates duplicates in
train_addresses (expected due to concatenation), resolved by keeping the first occurrence.
- Output:
- Warning about duplicates, confirming data cleaning.
- Features: ~44-48 columns (original + 4 graph-based:
in_degree, out_degree, clustering_coefficient, betweenness_centrality).
Handle Class Imbalance with SMOTE
- Purpose: Balances the dataset by oversampling the minority class (Sybil) using SMOTE.
- Steps:
- Ensures
y is binary (0/1) by converting to numeric and binarizing.
- Applies SMOTE to balance classes.
- Output:
Train-Test Split
- Purpose: Splits the resampled data into training and validation sets.
- Steps:
- Uses
train_test_split with 80:20 ratio, stratified on y_resampled.
- Output:
Hyperparameter Tuning for XGBoost
- Purpose: Tunes XGBoost hyperparameters using
GridSearchCV.
- Steps:
- Defines a parameter grid (e.g.,
max_depth, n_estimators, learning_rate).
- Uses 3-fold cross-validation with ROC-AUC scoring.
- Output:
-
Best XGBoost Parameters: {'alpha': 0, 'colsample_bytree': 0.8, 'lambda': 1, 'learning_rate': 0.1, 'max_depth': 7, 'n_estimators': 200, 'subsample': 1.0}
Best XGBoost ROC-AUC: 0.9992139265200622
- Parameters: Balanced settings (
max_depth=7, learning_rate=0.1), indicating a deep but regularized model.
- ROC-AUC: 0.9992, very high, as expected due to strong features and balanced data.
Train Other Models
- Purpose: Trains Random Forest, LightGBM, and CatBoost models with basic tuning.
- Steps:
- Random Forest:
n_estimators=200, max_depth=10, class_weight='balanced'.
- LightGBM:
n_estimators=200, max_depth=7, is_unbalance=True, verbose=-1.
- CatBoost:
iterations=200, depth=7, auto_class_weights='Balanced'.
Ensemble Methods
- Purpose: Implements Stacking and Voting ensembles using the trained models.
- Steps:
- Stacking: Combines XGBoost, Random Forest, LightGBM, and CatBoost with a Logistic Regression meta-model.
- Voting: Uses soft voting across the same models.
Evaluate Models and Check for Overfitting
- Purpose: Evaluates all models (XGBoost, Random Forest, LightGBM, CatBoost, Stacking, Voting) on training and validation sets.
- Function:
evaluate_model(model, X_train, y_train, X_val, y_val, model_name)
- Computes ROC-AUC, F1-Score, recall, precision, and overfitting gap.
- Plots confusion matrices.
- Output:
- XGBoost:
Training ROC-AUC: 0.9997
Validation ROC-AUC: 0.9993
Validation F1-Score: 0.9909
Validation Recall: 0.9950
Validation Precision: 0.9869
Overfitting Indicator (Train-Val ROC-AUC Gap): 0.0004
- Random Forest:
Training ROC-AUC: 0.9948
Validation ROC-AUC: 0.9941
Validation F1-Score: 0.9700
Validation Recall: 0.9800
Validation Precision: 0.9603
Overfitting Indicator (Train-Val ROC-AUC Gap): 0.0007
- LightGBM:
Training ROC-AUC: 0.9996
Validation ROC-AUC: 0.9991
Validation F1-Score: 0.9901
Validation Recall: 0.9949
Validation Precision: 0.9854
Overfitting Indicator (Train-Val ROC-AUC Gap): 0.0005
- CatBoost:
Training ROC-AUC: 0.9987
Validation ROC-AUC: 0.9980
Validation F1-Score: 0.9874
Validation Recall: 0.9933
Validation Precision: 0.9815
Overfitting Indicator (Train-Val ROC-AUC Gap): 0.0007
- Stacking:
Training ROC-AUC: 0.9997
Validation ROC-AUC: 0.9986
Validation F1-Score: 0.9932
Validation Recall: 0.9961
Validation Precision: 0.9903
Overfitting Indicator (Train-Val ROC-AUC Gap): 0.0011
- Voting:
Training ROC-AUC: 0.9994
Validation ROC-AUC: 0.9988
Validation F1-Score: 0.9886
Validation Recall: 0.9938
Validation Precision: 0.9835
Overfitting Indicator (Train-Val ROC-AUC Gap): 0.0006
- Confusion matrices plotted for each model.
Dynamic Threshold Optimization
- Purpose: Optimizes the classification threshold for multiple metrics (F1-Score, recall, precision-recall AUC).
- Function:
optimize_threshold_dynamic(y_true, y_pred_proba, metrics=['f1', 'recall', 'pr_auc'])
- Optimizes for:
f1: Maximizes F1-Score.recall: Maximizes recall with precision ≥ 0.95.pr_auc: Computes Precision-Recall AUC, uses F1-optimal threshold.
- Plots F1-Score vs. threshold, Recall vs. threshold, and PR curve.
- Output:
-
Threshold Optimization Results:
F1: Best Threshold = 0.7751, Score = 0.9939
RECALL: Best Threshold = 0.7751, Score = 0.9961
PR_AUC: Best Threshold = 0.7751, Score = 0.9986
- Plots: F1-Score, Recall, and PR curves, showing threshold selection.
- Best threshold (F1): 0.7751, F1-Score 0.9939, close to original (0.9940).
Feature Importance Analysis
- Purpose: Analyzes feature importance using XGBoost’s
feature_importances_ and SHAP.
- Output:
Cross-Validation
- Purpose: Performs 5-fold cross-validation to ensure robust performance.
- Steps:
- Uses
StratifiedKFold to maintain class balance.
- Trains the Stacking model on each fold, computes ROC-AUC.
- Output:
-
Cross-Validation ROC-AUC Scores: [0.999516648229417, 0.999653417270615, 0.9992871301288809, 0.999347305662059, 0.9993718291117792]
Mean CV ROC-AUC: 0.9994, Std: 0.0001
- Mean ROC-AUC 0.9994, Std 0.0001, indicating high performance and consistency.
Generate Test Predictions
- Purpose: Generates predictions for test addresses using the Stacking model and optimized threshold.
- Function:
prepare_test_submission(model, test_features, test_addresses_list, threshold, output_file)
- Aligns test features, predicts probabilities, applies threshold, saves submission.
- Submission saved to ‘submission_improved_2.csv’
- 20,369 unique test addresses
Techniques and Methods for High Accuracy
Data Preprocessing
- Label Binarization: Ensured
LABEL is binary (0/1), handling continuous or invalid values.
- SMOTE: Balanced classes (from 96,524:2,543 to 96,524:96,524), mitigating bias toward non-Sybil.
- Feature Scaling: Used
StandardScaler to normalize features, improving model convergence.
Feature Engineering
- Temporal Features:
tx_time_span_days (0.6438 importance) captures Sybil behavior (short activity spans).
- Graph-Based Features: Added
in_degree, out_degree, clustering_coefficient, betweenness_centrality to identify network patterns, though their importance was lower than expected due to sampling.
- Platform Features:
platform_hashflow-v3 (0.0175) highlights platform-specific Sybil behavior.
Model Training
- XGBoost: Achieved ROC-AUC 0.9993 with tuned parameters (
max_depth=7, learning_rate=0.1).
- Ensemble (Stacking): Combined models, achieving F1-Score 0.9932 and recall 0.9961, leveraging diverse strengths.
Dynamic Thresholding
- Optimized for F1-Score (0.9939), recall (0.9961), and PR-AUC (0.9986), ensuring flexibility in metric prioritization.
Overfitting Handling
- Small Gaps: Overfitting gap < 0.001 for most models (e.g., XGBoost 0.0004), indicating minimal overfitting.
- Cross-Validation: Std 0.0001 confirms consistency.
- Regularization: Used in XGBoost (
lambda=1), Random Forest (max_depth=10), and other models.
Feature Importance
- Top Features:
tx_time_span_days (0.6438): Dominant, as expected.tx_gas_used_std (0.0687), tx_fee_mean (0.0549): Indicate irregular transaction patterns.- Graph Features: Not in top 20, possibly due to sampling; may improve with larger subgraphs.
Conclusion
The model achieves exceptional performance (ROC-AUC 0.9994, F1-Score 0.9939, recall 0.9961), meeting expectations for Sybil detection. Graph-based features and dynamic thresholding enhance detection, though further optimization (e.g., larger graph samples) could improve graph feature importance. The model is robust, consistent, and ready for submission to the competition leaderboard.
Sybil Detection
1. Challenge Overview
2. Data Preparation
3. Feature Engineering
4. Modeling Approach