{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"pypi_pypi-lightgbm","slug":"pypi-lightgbm","name":"lightgbm","type":"repo","url":"https://github.com/microsoft/LightGBM","page_url":"https://unfragile.ai/pypi-lightgbm","categories":["model-training"],"tags":[],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"pypi_pypi-lightgbm__cap_0","uri":"capability://data.processing.analysis.leaf.wise.tree.growth.with.gradient.based.splitting","name":"leaf-wise tree growth with gradient-based splitting","description":"LightGBM grows decision trees leaf-wise (best-first) rather than level-wise, using histogram-based gradient computation to find optimal split points. Each iteration selects the leaf with maximum loss reduction and splits it, enabling faster convergence with fewer trees. The histogram-based approach quantizes continuous features into discrete bins, reducing memory footprint and enabling GPU acceleration.","intents":["Train gradient boosting models with faster convergence and lower memory usage than XGBoost","Build production ML pipelines that require efficient tree-based models on large datasets","Optimize model training time while maintaining or improving predictive accuracy"],"best_for":["Data scientists building tabular ML models on datasets with 100K+ rows","ML engineers optimizing training latency in production pipelines","Teams with GPU infrastructure seeking accelerated gradient boosting"],"limitations":["Leaf-wise growth can overfit on small datasets; requires careful regularization (min_child_samples, lambda_l1/l2)","Histogram binning introduces quantization error; continuous feature precision is lost after binning","GPU support requires CUDA 10.0+ and specific NVIDIA GPUs; CPU-only training is slower than GPU variants","Categorical feature handling via one-hot encoding can explode feature dimensionality for high-cardinality columns"],"requires":["Python 3.7+","NumPy 1.17+","SciPy 1.0+","scikit-learn 0.20+ (for sklearn API compatibility)","CUDA 10.0+ (optional, for GPU acceleration)"],"input_types":["numpy arrays (dense or sparse CSR/CSC matrices)","pandas DataFrames","LightGBM Dataset objects"],"output_types":["trained model object (booster)","predictions (regression/classification scores)","feature importance scores","leaf indices"],"categories":["data-processing-analysis","machine-learning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-lightgbm__cap_1","uri":"capability://data.processing.analysis.categorical.feature.native.handling.with.optimal.binning","name":"categorical feature native handling with optimal binning","description":"LightGBM natively handles categorical features without requiring one-hot encoding by treating them as ordered or unordered categories during split finding. The algorithm evaluates all possible category groupings to find optimal splits, using a greedy approach for high-cardinality features. This avoids the dimensionality explosion of one-hot encoding and preserves categorical semantics.","intents":["Train models on datasets with high-cardinality categorical features without feature explosion","Preserve categorical feature semantics without manual encoding preprocessing","Reduce memory usage and training time for datasets with many categorical columns"],"best_for":["Data scientists working with datasets containing 50+ categorical columns","ML engineers processing high-cardinality categorical features (100K+ unique values)","Teams avoiding manual feature engineering for categorical data"],"limitations":["Categorical handling assumes features are truly categorical; ordinal relationships must be encoded manually","High-cardinality features (>1000 unique values) may still require grouping to avoid exponential split complexity","Categorical feature splits are not monotonic; cannot enforce monotonic constraints on categorical features","Feature importance for categorical features is less interpretable than for numeric features"],"requires":["Python 3.7+","Features must be explicitly marked as categorical via categorical_feature parameter or pandas Categorical dtype","LightGBM Dataset object or pandas DataFrame with Categorical columns"],"input_types":["pandas DataFrame with Categorical dtype columns","numpy arrays with categorical_feature indices specified","LightGBM Dataset with categorical_feature parameter"],"output_types":["trained model with categorical split rules","feature importance scores","split statistics showing category groupings"],"categories":["data-processing-analysis","machine-learning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-lightgbm__cap_10","uri":"capability://automation.workflow.model.serialization.and.deserialization.to.json.and.binary.formats","name":"model serialization and deserialization to json and binary formats","description":"LightGBM models can be saved to JSON or binary formats and loaded back for inference. JSON format is human-readable and enables model inspection; binary format is compact and faster to load. Serialization preserves all model state including tree structure, feature names, and hyperparameters, enabling model portability across environments.","intents":["Save trained models for later inference without retraining","Deploy models to production systems with minimal dependencies","Share models with other teams or systems in standard formats"],"best_for":["ML engineers deploying models to production","Data scientists sharing models with other teams","Teams requiring model versioning and reproducibility"],"limitations":["JSON format is human-readable but 5-10x larger than binary format; slow to load for large models","Binary format is not human-readable; model inspection requires deserialization","Serialized models are version-specific; models trained with LightGBM 3.x may not load in 2.x","Custom loss functions and metrics are not serialized; must be reimplemented in inference code"],"requires":["Python 3.7+","trained LightGBM model (booster object)","file path for saving/loading"],"input_types":["trained LightGBM booster object"],"output_types":["JSON file (human-readable model representation)","binary file (compact model representation)","loaded booster object (for inference)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-lightgbm__cap_11","uri":"capability://data.processing.analysis.prediction.with.batch.and.single.sample.inference","name":"prediction with batch and single-sample inference","description":"LightGBM supports both batch prediction (multiple samples) and single-sample inference via predict() method. Batch prediction processes multiple samples efficiently using vectorized operations; single-sample inference is optimized for low-latency serving. Both modes support classification (class labels or probabilities) and regression (continuous values).","intents":["Generate predictions on new data for model evaluation","Deploy models for real-time inference on individual samples","Batch process large datasets for offline predictions"],"best_for":["ML engineers building inference pipelines","Data scientists evaluating model performance on test sets","Teams deploying models for real-time prediction serving"],"limitations":["Batch prediction requires all samples to have same feature structure; missing features must be handled before prediction","Single-sample inference has higher per-sample latency than batch prediction due to function call overhead","Predictions are deterministic; no uncertainty quantification (confidence intervals) without additional methods","Categorical features must be encoded identically to training; mismatched encoding leads to incorrect predictions"],"requires":["Python 3.7+","trained LightGBM model (booster object)","feature matrix with same structure as training data"],"input_types":["numpy arrays (dense or sparse CSR/CSC matrices)","pandas DataFrames","LightGBM Dataset objects"],"output_types":["predictions (numpy array)","class labels (for classification with num_class > 1)","class probabilities (for classification with pred_leaf=False)"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-lightgbm__cap_12","uri":"capability://safety.moderation.parameter.validation.and.automatic.type.conversion","name":"parameter validation and automatic type conversion","description":"LightGBM validates all hyperparameters at training time and provides helpful error messages for invalid values. The library automatically converts parameter types (e.g., string to int) when possible and warns about deprecated parameters. This reduces debugging time and prevents silent failures from mistyped parameters.","intents":["Catch hyperparameter errors early with clear error messages","Avoid silent failures from typos or incorrect parameter types","Migrate code when parameters are deprecated"],"best_for":["Data scientists new to LightGBM learning parameter semantics","ML engineers building automated training pipelines","Teams maintaining large codebases with many hyperparameter configurations"],"limitations":["Parameter validation is performed at training time, not at model creation; errors are delayed","Some invalid parameter combinations are not caught (e.g., conflicting regularization parameters)","Error messages are sometimes cryptic for complex parameter interactions","Type conversion can mask user errors (e.g., string '0.5' converted to float 0.5)"],"requires":["Python 3.7+","LightGBM 2.3.0+ (parameter validation improved in recent versions)"],"input_types":["hyperparameter dict or kwargs"],"output_types":["validation errors (exceptions with helpful messages)","warnings (for deprecated parameters)"],"categories":["safety-moderation","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-lightgbm__cap_13","uri":"capability://tool.use.integration.sklearn.api.compatibility.for.pipeline.integration","name":"sklearn api compatibility for pipeline integration","description":"LightGBM provides LGBMClassifier and LGBMRegressor classes that implement scikit-learn's estimator interface (fit, predict, score). This enables seamless integration with sklearn pipelines, GridSearchCV, and other sklearn tools. The sklearn API wraps the native LightGBM booster, maintaining performance while providing familiar interface.","intents":["Integrate LightGBM into existing sklearn-based ML pipelines","Use LightGBM with sklearn's GridSearchCV and cross-validation tools","Build end-to-end ML pipelines mixing LightGBM with sklearn preprocessing"],"best_for":["Data scientists familiar with sklearn ecosystem","ML engineers maintaining sklearn-based pipelines","Teams building end-to-end ML systems with multiple algorithms"],"limitations":["sklearn API doesn't expose all LightGBM features (e.g., custom loss functions, early stopping)","sklearn API adds ~5-10% overhead compared to native LightGBM API","Some LightGBM-specific parameters are not exposed in sklearn API; requires native API for full control","sklearn pipelines don't support LightGBM's distributed training"],"requires":["Python 3.7+","scikit-learn 0.20+","LightGBM 2.1.0+"],"input_types":["numpy arrays","pandas DataFrames","scipy sparse matrices"],"output_types":["predictions (numpy array)","model scores (float)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-lightgbm__cap_2","uri":"capability://data.processing.analysis.gpu.accelerated.training.with.cuda.kernels","name":"gpu-accelerated training with cuda kernels","description":"LightGBM provides GPU acceleration via CUDA kernels that parallelize histogram computation and gradient aggregation across GPU threads. The GPU implementation maintains the same algorithmic behavior as CPU training while offloading compute-intensive operations to NVIDIA GPUs. Training data is transferred to GPU memory once, and gradients are computed in parallel across thousands of CUDA threads.","intents":["Accelerate gradient boosting training on large datasets using GPU hardware","Reduce training time from hours to minutes for million-row datasets","Scale model training to larger datasets within fixed time budgets"],"best_for":["ML engineers with access to NVIDIA GPU infrastructure (V100, A100, RTX series)","Teams training models on datasets with 1M+ rows where CPU training is prohibitively slow","Production pipelines requiring sub-hour training times for large-scale models"],"limitations":["GPU memory is typically 8-80GB; datasets larger than GPU memory require data sampling or out-of-core training","GPU acceleration only benefits large datasets (100K+ rows); overhead of GPU transfer makes small datasets slower","CUDA 10.0+ and specific NVIDIA GPU architectures required; no support for AMD GPUs or Apple Metal","GPU training produces slightly different results than CPU due to floating-point precision differences in parallel reduction"],"requires":["CUDA 10.0+ toolkit installed and in PATH","NVIDIA GPU with compute capability 3.5+ (Kepler generation or newer)","LightGBM compiled with GPU support (gpu_platform=cuda)","cuDNN 7.0+ (optional, for some GPU operations)"],"input_types":["numpy arrays (transferred to GPU memory)","pandas DataFrames (converted to GPU arrays)","LightGBM Dataset objects"],"output_types":["trained model (identical API to CPU training)","predictions","feature importance scores"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-lightgbm__cap_3","uri":"capability://automation.workflow.distributed.training.across.multiple.machines.via.mpi.socket","name":"distributed training across multiple machines via mpi/socket","description":"LightGBM supports distributed training across multiple machines using MPI (Message Passing Interface) or socket-based communication. Each worker machine processes a partition of the dataset, computes local histograms, and communicates them to a master node for aggregation. The master finds global optimal splits and broadcasts them to all workers, enabling horizontal scaling of training.","intents":["Train models on datasets too large for a single machine's memory","Scale training across a cluster of machines to reduce wall-clock training time","Build distributed ML pipelines for enterprise-scale data processing"],"best_for":["ML engineers with access to multi-machine clusters or cloud infrastructure","Teams training on datasets with 10B+ rows distributed across multiple nodes","Organizations requiring fault-tolerant distributed training pipelines"],"limitations":["Network communication overhead can dominate training time if histogram sizes are large or network bandwidth is limited","Requires careful tuning of num_machines, num_threads, and feature_fraction to balance communication vs computation","MPI setup and debugging is complex; requires system-level configuration and network expertise","Distributed training produces slightly different results than single-machine training due to floating-point precision in distributed reduction"],"requires":["Python 3.7+","MPI implementation (OpenMPI or MPICH) installed on all machines","Network connectivity between all machines with low-latency communication","LightGBM compiled with MPI support (mpi=ON)","Shared filesystem or data replication strategy for dataset access"],"input_types":["partitioned datasets (each machine reads its partition)","LightGBM Dataset objects with data_sample_strategy='bagging'"],"output_types":["trained model (aggregated across all workers)","predictions","feature importance scores"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-lightgbm__cap_4","uri":"capability://planning.reasoning.early.stopping.with.validation.set.monitoring","name":"early stopping with validation set monitoring","description":"LightGBM monitors a validation set during training and stops early if validation metric (AUC, log loss, RMSE, etc.) stops improving for a specified number of rounds. The implementation tracks the best validation score and model state, allowing rollback to the best iteration. Early stopping prevents overfitting and reduces unnecessary training iterations.","intents":["Prevent overfitting by stopping training when validation performance plateaus","Reduce training time by avoiding unnecessary boosting iterations","Automatically find optimal number of boosting rounds without manual tuning"],"best_for":["Data scientists tuning hyperparameters and seeking automatic convergence detection","ML engineers building production pipelines with time constraints","Teams avoiding manual iteration count selection"],"limitations":["Requires a separate validation set; reduces training data available for model fitting","Early stopping is metric-specific; must choose appropriate metric for the problem (AUC for classification, RMSE for regression)","Validation set must be representative; biased validation sets lead to premature or delayed stopping","Early stopping adds ~5-10% overhead per iteration for validation metric computation"],"requires":["Python 3.7+","Validation dataset with labels","eval_set parameter with validation data and labels","early_stopping_rounds parameter (typically 10-50)"],"input_types":["training dataset (numpy array, pandas DataFrame, or LightGBM Dataset)","validation dataset with same feature structure"],"output_types":["trained model (at best validation iteration)","best_score (best validation metric value)","best_iteration (iteration with best validation score)"],"categories":["planning-reasoning","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-lightgbm__cap_5","uri":"capability://planning.reasoning.feature.importance.computation.via.gain.split.and.cover.metrics","name":"feature importance computation via gain, split, and cover metrics","description":"LightGBM computes feature importance using three metrics: gain (total loss reduction from splits on that feature), split (number of times feature is used for splitting), and cover (number of samples affected by splits on that feature). These metrics are computed during training from the tree structure and can be aggregated across all trees. Feature importance helps identify which features drive model predictions.","intents":["Identify which features are most important for model predictions","Debug model behavior and validate that important domain features are being used","Select features for model simplification or feature engineering"],"best_for":["Data scientists performing model interpretability analysis","ML engineers validating that models use expected features","Teams building explainable AI systems requiring feature attribution"],"limitations":["Feature importance is model-specific; doesn't indicate feature importance for the true underlying relationship","Gain-based importance is biased toward high-cardinality features; split-based importance is biased toward frequently-used features","Feature importance doesn't capture feature interactions; two interacting features may have low individual importance","Importance values are not normalized across different datasets or model configurations"],"requires":["Python 3.7+","trained LightGBM model (booster object)","importance_type parameter ('gain', 'split', or 'cover')"],"input_types":["trained LightGBM booster object"],"output_types":["feature importance scores (numpy array or pandas Series)","feature names (if provided during training)"],"categories":["planning-reasoning","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-lightgbm__cap_6","uri":"capability://planning.reasoning.custom.loss.function.and.metric.support.via.callback.interface","name":"custom loss function and metric support via callback interface","description":"LightGBM allows users to define custom loss functions and evaluation metrics via Python callbacks. Custom loss functions receive predictions and labels, compute gradients and Hessians, and return them for tree fitting. Custom metrics receive predictions and labels, compute any metric, and return a score. This enables optimization for domain-specific objectives not covered by built-in losses.","intents":["Optimize models for custom business metrics (e.g., profit, fairness constraints)","Implement domain-specific loss functions (e.g., asymmetric costs, quantile regression)","Integrate LightGBM into specialized ML workflows with non-standard objectives"],"best_for":["ML engineers building models with custom business objectives","Data scientists implementing specialized loss functions (quantile, focal, custom ranking)","Teams requiring fairness or constraint-based optimization"],"limitations":["Custom loss functions must be differentiable; non-differentiable objectives require approximation","Gradient and Hessian computation is user's responsibility; incorrect implementation leads to poor model quality","Custom loss functions are slower than built-in losses (no C++ optimization); ~20-50% training overhead","Custom metrics are computed on full validation set each iteration; large validation sets add significant overhead"],"requires":["Python 3.7+","trained LightGBM model or training in progress","custom loss function with signature: fobj(y_true, y_pred) -> (grad, hess)","custom metric with signature: feval(y_true, y_pred) -> (metric_name, score, is_higher_better)"],"input_types":["predictions (numpy array)","labels (numpy array)"],"output_types":["gradients and Hessians (for loss functions)","metric scores (for evaluation metrics)"],"categories":["planning-reasoning","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-lightgbm__cap_7","uri":"capability://planning.reasoning.shap.value.computation.for.model.agnostic.feature.attribution","name":"shap value computation for model-agnostic feature attribution","description":"LightGBM integrates with SHAP (SHapley Additive exPlanations) library to compute Shapley values, which represent each feature's contribution to individual predictions. SHAP values are computed by evaluating the model on feature subsets and aggregating contributions. This provides model-agnostic explanations of why the model made specific predictions.","intents":["Explain individual predictions to stakeholders and end-users","Identify which features influenced specific model decisions","Debug model behavior on individual samples"],"best_for":["Data scientists building interpretable ML systems","ML engineers in regulated industries requiring prediction explanations","Teams building user-facing ML applications with explainability requirements"],"limitations":["SHAP computation is expensive; O(2^num_features) complexity for exact computation, requiring approximation for high-dimensional data","SHAP values are model-specific; don't indicate true feature importance for underlying data distribution","SHAP computation requires access to training data for background distribution; privacy concerns in sensitive applications","SHAP values can be misleading if features are correlated; Shapley values assume feature independence"],"requires":["Python 3.7+","SHAP library (pip install shap)","trained LightGBM model","background dataset for SHAP explainer (typically training data sample)"],"input_types":["trained LightGBM model","feature matrix (numpy array or pandas DataFrame)","background dataset (for SHAP explainer)"],"output_types":["SHAP values (numpy array, shape: num_samples x num_features)","base value (model's average prediction)","SHAP plots (waterfall, force, dependence plots)"],"categories":["planning-reasoning","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-lightgbm__cap_8","uri":"capability://planning.reasoning.cross.validation.with.stratified.and.time.series.splits","name":"cross-validation with stratified and time-series splits","description":"LightGBM provides cv() function for k-fold cross-validation with support for stratified splits (preserving class distribution) and time-series splits (respecting temporal order). The function trains k models on different data splits, evaluates each on held-out fold, and aggregates metrics. This enables robust model evaluation and hyperparameter tuning.","intents":["Evaluate model performance with robust cross-validation","Tune hyperparameters using cross-validated metrics","Assess model stability across different data splits"],"best_for":["Data scientists performing model evaluation and hyperparameter tuning","ML engineers validating model performance before deployment","Teams working with time-series data requiring temporal validation"],"limitations":["k-fold CV requires training k models; ~k times slower than single train-test split","Stratified CV assumes labels are available; unsupervised learning requires custom split logic","Time-series CV assumes temporal order is preserved; requires careful data preparation","CV results are sensitive to fold size and random seed; small folds lead to high variance"],"requires":["Python 3.7+","training dataset with labels","folds parameter (number of folds, typically 5 or 10)","stratified parameter (True for classification, False for regression)"],"input_types":["training dataset (numpy array, pandas DataFrame, or LightGBM Dataset)","labels (numpy array or pandas Series)","folds parameter (int or custom fold generator)"],"output_types":["cross-validation results (dict with metric scores per fold)","mean and std of metrics across folds","trained models (one per fold, if return_models=True)"],"categories":["planning-reasoning","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-lightgbm__cap_9","uri":"capability://planning.reasoning.hyperparameter.optimization.via.grid.search.and.random.search","name":"hyperparameter optimization via grid search and random search","description":"LightGBM integrates with scikit-learn's GridSearchCV and RandomizedSearchCV for systematic hyperparameter tuning. Users define parameter grids, and the search algorithm trains models with different parameter combinations, evaluates them via cross-validation, and returns the best parameters. This enables automated hyperparameter optimization without manual trial-and-error.","intents":["Automatically find optimal hyperparameters for a dataset","Explore hyperparameter space systematically without manual tuning","Compare different hyperparameter configurations fairly via cross-validation"],"best_for":["Data scientists tuning models for new datasets","ML engineers building automated ML pipelines","Teams with limited domain expertise in hyperparameter tuning"],"limitations":["Grid search is exponential in number of parameters; 10 parameters with 10 values each = 10B combinations","Random search is more efficient but may miss optimal regions; requires careful sampling strategy","Hyperparameter optimization is computationally expensive; can require hours or days for large datasets","Optimal hyperparameters are dataset-specific; transfer learning of hyperparameters is unreliable"],"requires":["Python 3.7+","scikit-learn 0.20+","LightGBM sklearn API (LGBMClassifier or LGBMRegressor)","parameter grid definition"],"input_types":["training dataset (numpy array or pandas DataFrame)","labels (numpy array or pandas Series)","parameter grid (dict of parameter names to lists of values)"],"output_types":["best parameters (dict)","best cross-validation score (float)","grid search results (DataFrame with all combinations and scores)"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":26,"verified":false,"data_access_risk":"high","permissions":["Python 3.7+","NumPy 1.17+","SciPy 1.0+","scikit-learn 0.20+ (for sklearn API compatibility)","CUDA 10.0+ (optional, for GPU acceleration)","Features must be explicitly marked as categorical via categorical_feature parameter or pandas Categorical dtype","LightGBM Dataset object or pandas DataFrame with Categorical columns","trained LightGBM model (booster object)","file path for saving/loading","feature matrix with same structure as training data"],"failure_modes":["Leaf-wise growth can overfit on small datasets; requires careful regularization (min_child_samples, lambda_l1/l2)","Histogram binning introduces quantization error; continuous feature precision is lost after binning","GPU support requires CUDA 10.0+ and specific NVIDIA GPUs; CPU-only training is slower than GPU variants","Categorical feature handling via one-hot encoding can explode feature dimensionality for high-cardinality columns","Categorical handling assumes features are truly categorical; ordinal relationships must be encoded manually","High-cardinality features (>1000 unique values) may still require grouping to avoid exponential split complexity","Categorical feature splits are not monotonic; cannot enforce monotonic constraints on categorical features","Feature importance for categorical features is less interpretable than for numeric features","JSON format is human-readable but 5-10x larger than binary format; slow to load for large models","Binary format is not human-readable; model inspection requires deserialization","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.35,"ecosystem":0.39999999999999997,"match_graph":0.25,"freshness":0.9,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.3,"freshness":0.05}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:25.060Z","last_scraped_at":"2026-05-03T15:20:16.568Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=pypi-lightgbm","compare_url":"https://unfragile.ai/compare?artifact=pypi-lightgbm"}},"signature":"yWha0Ot3N2t7Ghcc6HgMZ3DOwzcekFyt1zEmD7ns0eSnu8rnCUYHdjPVEWrdZSbR8OvXgoaohDwnM1on0xvbCQ==","signedAt":"2026-06-15T18:20:44.927Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/pypi-lightgbm","artifact":"https://unfragile.ai/pypi-lightgbm","verify":"https://unfragile.ai/api/v1/verify?slug=pypi-lightgbm","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}