
Use linear assignment problem (LAP/lapjv) on a score matrix to select globally optimal hard-negative pairs for metric learning
Local search that slides a window of size p across a word sequence, brute-forcing all permutations within each window to minimize an objective like LLM perplexity
Rank candidate prompts by computing LLM perplexity of the full conversation conditioned on each prompt, selecting the lowest-perplexity candidate as the best match
Greedy local search that removes one element from a fixed position and re-inserts it at every possible index, keeping the best improvement per round
Batch-compute perplexity for multiple texts using a causal LM with proper padding, shifted labels, and pad-token masking for efficient GPU utilization
Pad 3D volumes with fewer slices than required by duplicating existing slices with slight brightness variation via convertScaleAbs
All-vs-all contrastive loss comparing every pair in a batch (N^2 pairs) with margin and compactification regularizer
Split validation by unique anchor/query entities so no anchor appears in both train and val, preventing data leakage in pairwise matching tasks
Reshapes model predictions to match the known label distribution from training data using rank-based mapping.
Adds each feature's value-count frequency as a new column, enabling tree models to split on how common or rare a value is.
Uses GroupKFold to prevent data leakage when multiple rows share a common entity (e.g., same user, question, or document).
Splits train/validation using GroupShuffleSplit so that related samples (forks, families, sessions) never span both sets.
Use LightGBM DART boosting (dropout on trees) with aggressive feature and bagging fractions to reduce overfitting on high-dimensional tabular data
Average model predictions across CV folds in log-odds space rather than probability space for better-calibrated ensemble outputs
Scores features by comparing actual importances against a null distribution from shuffled targets, removing features that cannot beat random noise.
Generates all C(n,2) pairwise feature combinations, target-encodes each pair with cuML TargetEncoder, then applies logit polynomial expansion (z, z^2, z^3) for stacking with cuML LogisticRegression.
Augments training data with high-confidence test predictions as pseudo labels, retrains the model, and keeps the result only if OOF AUC improves. A semi-supervised technique for tabular competitions.
Generates polynomial powers and interaction terms from selected numeric features to capture nonlinear relationships with the target.
Engineers row-wise statistical features (sum, mean, std, skew, kurtosis, median, min, max) across all numeric columns per sample.
Normalizes each sample's multi-output target vector to zero mean and unit variance, removing per-sample scale differences before training.
Compute min/max/mean/std of Euclidean distances from all entities to a key point, then aggregate per group for spatial feature engineering
Detects synthetic/fake test samples by checking whether each row has at least one unique value across all features — real samples do, synthetic ones don't.
Applies rolling mean or Butterworth low-pass filter to model predictions for temporal consistency and noise reduction.
Map free-text categorical descriptions to ordinal numeric scores via keyword matching — captures ordered severity in a single dense feature
Evaluate recommendation quality with recall@K per action type, combined via business-importance weights
Process multiple sensor modalities through separate CNN branches then fuse via a transformer with CLS token for classification
Combines dilated 1D convolutions for multi-scale receptive fields with residual bidirectional GRU layers for sequence classification.
Detects discrete events (state transitions) from continuous predictions using local maxima with minimum-interval constraints.
Negative log-likelihood loss over K isotropic-Gaussian trajectory modes with per-mode confidences and logsumexp stability
Decompose multi-output prediction into a global mean (1D model) plus per-channel residuals (2D model) with quadrature uncertainty
Apply MixUp augmentation to padded time-series batches with Beta-distributed lambda and soft label mixing
1D ResNet block with Squeeze-and-Excitation channel attention for temporal sensor feature extraction
Predefines minimal unsigned integer dtypes before CSV loading to cut DataFrame memory usage by 2-4x without any data loss.
Scaled Pinball Loss (SPL) metric for evaluating quantile forecasts, normalized by mean absolute successive differences of training data
Transform forecasting target to next/current ratio minus one so that optimizing MAE or squared error implicitly minimizes SMAPE
Walk backward through a time series and multiplicatively rescale segments when jumps exceed a fraction of the running mean to correct data collection anomalies
Simulated annealing with diverse move operators (translate, rotate, swap, Levy flight, squeeze) and adaptive reheating on stagnation for combinatorial optimization
Convert a density metric back to integer counts using known population, round to nearest integer, then recompute density to exploit the discrete nature of the target
Custom Keras RMSLE metric using K.log with K.clip to safely evaluate price and count regression during training
Extract per-frame CNN features then classify the temporal sequence with stacked GRU layers and a boolean mask for variable-length video inputs
Partition a large dataset into N balanced shards using integer key modulo arithmetic for reproducible, class-interleaved splits across CSV files
Generate descriptive text prompts from images by combining BLIP captioning with CLIP cosine similarity against curated label banks for medium, movement, and flavor attributes
GPU-accelerated k-NN regression on CLIP image embeddings using cosine distance and inverse-distance-power weighting to predict target embedding vectors
Score candidate movement directions by average distance to nearby opponents and pick the safest path for ball-carrying agents in game AI
Use sklearn FeatureUnion with closure-based preprocessors to apply different vectorizers to different DataFrame columns in a single fit_transform call
Recover missing categorical values by matching words in a related text field against a known vocabulary built from the full dataset
Predict where a projectile will land using kinematic equations with estimated gravity to intercept aerial passes in game AI simulations
Latent Dirichlet Allocation on CountVectorizer bag-of-words to discover latent topics with per-document topic distributions for feature engineering or EDA
Encode text prompts into fixed-length dense vectors using SentenceTransformer for cosine-similarity evaluation in image-to-text retrieval tasks
Double left-join on tracking data to create pairwise features (positions, velocities, distance) for both entities in an interaction pair
Normalize high-dynamic-range satellite or medical imagery to [0,1] using per-channel percentile clipping to suppress outliers while preserving relative contrast
Convert binary segmentation masks to Shapely MultiPolygons using cv2 contour hierarchy to correctly handle interior holes, with Douglas-Peucker simplification
Select center slices from a 3D volume and zero-pad along depth when the scan has fewer slices than the target count
Aggregate high-dimensional spatial sensor grids into hierarchical region statistics at multiple granularities
Randomly zero out entire sensor modalities during training with a learned gate to handle missing modalities at inference
Train a single Poisson LightGBM count forecaster, then ensemble its predictions with multiple multiplicative scaling factors (alpha ≈ 1.02-1.03) to undo the systematic downward bias of Poisson regression on intermittent retail data
Derive angular velocity from consecutive quaternion frames via relative rotation and rotvec conversion
Fill gaps in a daily exogenous series (oil prices, sensor feeds) by merging against a full calendar to expose NaNs, then replacing each NaN with the midpoint of its nearest valid left and right neighbors, walking outward past consecutive NaN runs
Computes rolling mean/max/std at multiple window sizes plus total variation (abs first differences) for multi-resolution temporal context.
Generate shift/diff features at multiple lag sizes (1,2,3,5,10,20,50,100) over cursor/time/state series, then aggregate statistics per session
Build a single per-row "day off" boolean from a holidays table with National/Regional/Local locale hierarchy and Work Day overrides that flip make-up working weekends back to working days
Weight multi-channel signals by inverse per-channel variance with percentile clipping, emphasizing low-noise channels in aggregation
Detect event ingress/egress boundaries by finding steepest gradient on each side of the signal minimum in a smoothed time series
Detect event start/end boundaries in time series by finding extrema of the first derivative (steepest gradient points)
Align low-Hz sensor data to high-fps video by anchoring a named event (e.g. ball_snap) to a known frame index and converting time offsets via fps
Multi-step detector calibration pipeline — ADC inversion, hot/dead pixel masking, nonlinearity correction, dark subtraction, flat-field normalization
Subtract paired reference frames from signal frames to cancel readout noise and common-mode bias
Split a multi-year table into per-year partitions, run the same groupby aggregation on each, then concat and gc — a pure-pandas map-reduce that survives 100M+ rows on a 16GB kernel
Use XGBoost DeviceQuantileDMatrix with a custom batch iterator to train on large datasets without exhausting GPU memory
Ensemble ranked recommendation lists by outer-joining exploded candidates and re-ranking by weighted vote sum
Aggregate panel/sequential data with type-appropriate statistics — numeric (mean/std/min/max/last) and categorical (count/last/nunique) — then concat into flat features
Custom ranking metric combining normalized weighted Gini coefficient with top-K% capture rate for imbalanced classification with class-weighted evaluation
Aggregates deeply nested relational tables through two groupby levels (child → intermediate → parent) to build features from multi-hop relationships.
Builds user-level features by accumulating statistics across sequential event sessions before each assessment point.
Reshapes tabular features into 2D pseudo-images via random feature permutation, enabling CNN-based feature interaction learning.
Compresses high-dimensional targets with TruncatedSVD, trains on the reduced space, then reconstructs full predictions via the components matrix.
Train LightGBM directly on a scipy.sparse.hstack of TF-IDF text vectors and dense tabular columns, passing feature_name and categorical_feature so native categorical handling survives the sparse block
Convert a scalar regression prediction into a smoothed CDF over discrete bins using a linear ramp instead of a hard step
Computes all numeric RDKit molecular descriptors from SMILES strings, filtering out NaN, constant, and infinite values to produce a clean feature matrix.
Mirror spatial coordinates and angles so all plays face the same direction — removes left/right asymmetry from sports and spatial data
Detect all-black DICOM/MRI slices (mean==0) and replace them by randomly sampling a non-black slice from the same series
Fuse low-resolution multispectral bands with a high-resolution panchromatic band using the Brovey transform to produce sharp multi-band imagery
Parse structured text fields like '1 RB, 2 TE, 2 WR' into separate numeric columns per category
Score each face in a video as anomalous by computing L2 distance from the embedding centroid of all faces, then convert to probability via logistic function
Encode game state as a Super Mini Map (SMM) with separate binary channels for players, ball, and ownership, bit-packed for efficient transfer in RL training
Post-processing correction for multi-output regression — scale each output by its train-derived mean ratio to fix systematic per-feature bias
Apply VarianceThreshold within each data partition on combined train+test to select informative features per subgroup
Serialize structured ground truth (chart data, table rows, form fields) as special-token-delimited sequences for generative vision-language model training
Pad batch sequence lengths to multiples of 8 for efficient tensor core utilization on GPUs, with -100 masking for label padding
Add random temporal offset to the center frame during training to augment temporal diversity in video-based models
When a regression target has a long discrete tail (e.g. ~1% of rows pinned at -33.22 in Elo), train one regressor on the *non-outlier* subset, a separate binary classifier for the outlier flag, and splice the predictions — replace the top-K most-confident outlier predictions in the regressor's output with the outlier value, where K is calibrated on validation
Computes seconds until the next event within a group using diff().shift(-1) on sorted timestamps, capturing user behavior velocity.
Truncate LLM output to exactly N sentences and fall back to a known-good baseline string when output is empty or too short
Agents patrol in expanding spiral patterns using rotating direction sequences with increasing radius for systematic grid exploration
Three-level polygon overlap test — AABB early exit, then point-in-polygon ray casting, then segment intersection — for fast non-convex collision detection
Fuse recommendation candidates from user history, multiple co-visitation matrices, and global popularity in a priority-ordered cascade
Keras multi-input model with separate embedding layers for categoricals, GRU for text sequences, and dense layers for numerics, all concatenated into a shared regression trunk
Iterates through rows chronologically to accumulate user statistics, fetching current state before updating to prevent future data leakage.
Predict day-by-day via Kaggle's iter_test API while maintaining a rolling history buffer for computing lag features online
Generate lag features for multiple targets over N days by shifting evaluation dates and self-joining per entity, creating a wide feature matrix of past target values
Alternating Least Squares matrix factorization on sparse user-item interaction matrices for implicit feedback recommendations.
Encodes cyclical features (hour, month, day-of-week) using sine/cosine transforms to preserve circular distance.
Use Pearson correlation coefficient as evaluation metric for semantic similarity regression tasks, selecting best checkpoint by correlation rather than loss
Two-stage pipeline where an unsupervised bi-encoder retrieves KNN candidates and a supervised cross-encoder reranks them with sigmoid thresholding
Enrich model input by mapping categorical codes to human-readable taxonomy descriptions and concatenating them as context for transformer models
Explicitly zero all dropout probabilities in transformer config at load time for fully deterministic inference
Trainable nonlinear distance metric that transforms (v1-v2) and (v1-v2)^2 through a linear layer before computing squared norm
Resolve overlapping instance masks by greedily assigning contested pixels to higher-confidence predictions using a running occupancy map
Add a cumulative sum channel along the vertical axis to capture directional structural trends in grayscale images for segmentation
Parallel-load per-subject parquet time-series files with ThreadPoolExecutor and flatten describe() statistics into tabular feature vectors
Shape RL rewards with time-decaying asset weights and time-increasing resource weights so the agent transitions from expansion to accumulation as the game progresses
Compute shortest Manhattan distance on a toroidal (wrapping) grid by comparing normal vs wrap-around routes in each axis
Fit unsupervised transforms (scaler, PCA, variance filter) on combined train+test data for more stable statistics, especially on small datasets
Post-processes entity match predictions to enforce symmetry (A→B implies B→A) and transitivity (A→B, B→C implies A→C) via graph closure.
Extract volumetric features from 3D segmentation masks including scan/tumor pixel ratios, tumor percentage, and tumor centroid coordinates
Rebuild multi-turn conversation context by interleaving user/assistant turns with chat template tokens into a single prompt each call
Use LightGBM's tweedie objective with variance_power between 1.05 and 1.2 for zero-inflated count forecasting (retail SKUs, intermittent demand, click events) — handles the "many zeros plus a heavy right tail" distribution that breaks both regression (RMSE) and classification (BCE) objectives
Train segmentation with BCE loss first for stable convergence, then fine-tune with Lovasz-hinge on raw logits for IoU-optimal predictions
Estimate out-of-distribution class probability as the product of (1 - p_i) across all known classes, scaled by a calibrated prior
Efficiently sample N evenly-spaced frames from a video using OpenCV grab/retrieve pattern with optional resize for batch face detection or classification
Denoise an erratic 1D series with discrete wavelet decomposition + universal soft thresholding (sigma estimated from MAD of the detail coefficients) to extract the underlying trend/seasonality without lagging the signal — a far better trend extractor than rolling means for spiky retail or sensor data
Ensemble predictions from heterogeneous vision-language models by blending their output embeddings with fixed scalar weights in embedding space
Ensembles multiple ranked recommendation lists by scoring items as model_weight / position_rank, then re-ranking.
Convert per-instance RLE or polygon annotations to COCO JSON format for seamless use with Detectron2 and MMDetection
Execute Python code blocks from LLM math responses in a sandbox, then double-weight code-derived answers in majority voting
Removes redundant features by iterating pairwise Pearson correlations and dropping one member of each pair exceeding a threshold.
Encode a 2D game board into a normalized multi-channel feature tensor with log-scaled resources, signed unit counts, and directional features for RL agents
Train separate models per imaging modality (FLAIR/T1w/T1wCE/T2w) and average their predictions for final ensemble
Multi-round pseudo labeling with progressively confident test predictions merged into training plus OOF-based train label correction
3D ResNet encoder extracts volumetric features, pools depth dimension, then feeds into a 2D UNet/FPN decoder for segmentation
Load large LLMs with 4-bit NF4 quantization and optional double quantization via BitsAndBytes to reduce GPU memory by 4x while preserving inference quality
Override model predictions with last known value for low-activity or low-density entities where learned trends are unreliable
Shared-backbone neural network with actor (policy) and critic (value) heads for grid-based game agent RL training
Dynamically reduce max_tokens and batch size as wall-clock time approaches a cutoff to ensure all inputs get processed
Parse sequential yes/no answers to build inclusion/exclusion sets, then apply compound boolean filters to narrow a candidate list
Train a PyTorch autoencoder on time-series summary statistics to produce dense encoded features for downstream GBDT models
Multiply per-timestep regression loss by a 0/1 availability mask so missing future steps contribute zero gradient
Interpolate missing bounding boxes across video frames using bidirectional pandas interpolation to maintain smooth tracking through occlusions
When no candidate passes the threshold for a query, fall back to the single highest-scoring match to guarantee at least one prediction per query
Force-clamp free-form LLM output to binary yes/no with keyword matching and a fallback default for constrained environments
Hierarchical binary search over entity space by asking category, region, then first-letter questions to narrow candidates before guessing
Generate prediction intervals by repeatedly sampling from model residuals, adding to point forecasts, and taking quantiles across synthetic futures
Extract final numeric answers from LaTeX \boxed{} notation in LLM math reasoning output, scanning matches in reverse for robustness
Detect P-bursts (fast-typing runs) and R-bursts (consecutive revisions) via polars run-length encoding over boolean event conditions
Per-agent COLLECT/DEPOSIT state machine driven by cargo thresholds with greedy neighbor selection for resource collection games
Select a fixed number of Z-slices centered around the volume midpoint for memory-efficient 2.5D input from 3D CT/MRI stacks
Predict correlated targets sequentially, using earlier target predictions as input features for subsequent targets to exploit inter-target dependencies
Memory-efficient Keras generator that streams sharded CSV files in chunks, renders strokes to images on-the-fly, and yields batches for training on datasets too large for memory
Sample training patches from large images using per-class area-fraction thresholds to ensure each patch contains meaningful object coverage
Manual stable diffusion inference loop with classifier-free guidance that interpolates between unconditional and conditional noise predictions for controllable image generation
Custom multiclass log-loss that weights per-class contributions by class frequency and domain importance, usable as both training loss and eval metric
Augments imbalanced tabular data by independently shuffling each feature column within a class, creating synthetic samples that preserve per-column marginal distributions.
Hard-clips predicted probabilities to 0 or 1 when they exceed high-confidence thresholds, reducing log loss on near-certain predictions.
Encodes categorical groups by their target rate scaled by a log-confidence factor, smoothing unreliable rates from low-frequency groups toward zero.
Precomputes item/content difficulty as historical mean accuracy, merged as a static feature for user-item prediction tasks.
Stack 1D convolutions for local feature extraction before bidirectional LSTMs to classify variable-length stroke sequences into hundreds of doodle categories
Recommends items frequently purchased together with a customer's recent items using pre-computed pair dictionaries.
Stratify train/validation split by binned mask coverage percentage to ensure balanced foreground representation in segmentation tasks
Build user-level behavioral features (avg listing duration, relisting frequency, total items) by joining auxiliary activity tables that share user_id but not item_id with train/test
Model cumulative distribution via softmax output layer and CRPS loss — for probabilistic regression over discrete bins
Resize images preserving aspect ratio then zero-pad to a square to avoid distortion artifacts in face crops or object detection inputs
Custom Detectron2 data mapper with photometric augmentations that properly transforms images, bounding boxes, and instance masks in sync
Structured prompt template for recovering the instruction that transformed one text into another, with labeled original/rewritten fields and explicit task framing
Config-driven feature factory that generates groupby aggregation features from a declarative spec list, supporting count, mean, var, nunique, cumcount, and custom lambdas.
Add domain-specific categorical values as new special tokens, resize embeddings, and prepend them to input so the model learns domain-aware representations
Single agent entry point that dispatches between multiple roles (ask/answer/guess) based on turn type, combining heuristic and LLM-based strategies
Reshape dual-view stacked channels into doubled batch dimension for shared backbone, then concatenate with tabular features for classification
Estimate prediction uncertainty via Monte Carlo Dropout — run inference N times with dropout active and compute mean/std
Enumerate all factorial permutations in batches with LLM scoring, tracking the running best and early-stopping when score crosses a known optimality threshold
Walk-forward stacking ensemble that trains base models on expanding windows and a meta-learner on their out-of-fold predictions across time
Engineer SNR-derived features from irregular time series — flux ratio squared, error-weighted mean flux, and normalized amplitude/range features
Encode motion and velocity by computing per-channel pixel differences between consecutive frames instead of stacking raw frames for RL visual observations
Evaluate probabilistic forecasts using normalized Gaussian log-likelihood relative to naive and oracle baselines, scoring both mean accuracy and uncertainty calibration
Clean noisy numeric strings from generative model output by removing invalid characters, fixing malformed floats, and handling multiple decimal points
Fits a Gaussian Mixture Model on the joint feature-target space and samples synthetic data pairs to augment small tabular datasets.
Custom evaluation metric that computes log of per-group MAE then averages, penalizing uniformly bad groups.
Constructs a customer similarity graph via KNN on mixed features, then trains a GraphSAGE GNN for node classification. Captures relational patterns that tree and linear models miss, adding ensemble diversity.
Generates geographically proximate candidate pairs for entity matching using KNN with haversine distance, optionally partitioned by country.
Two-level group-then-pattern dispatch for game AI agents where groups filter by game state and ordered patterns within a group fire the first matching action
Assign different uncertainty spread coefficients per aggregation level in hierarchical forecasts, reflecting that higher aggregation yields narrower intervals
Remove gravity component from raw accelerometer data using quaternion rotation to yield linear acceleration
Computes leak-free target encoding statistics (mean, std, min, max) using nested inner KFold within each outer CV fold, preventing target leakage that occurs with naive groupby-based encoding.
Replace the actual input text with a generic low-meaning passage to prevent the LLM from fixating on content specifics, forcing it to focus on stylistic and structural transformation cues
Single neural network outputting all quantiles simultaneously via pinball loss over a quantile vector for joint probabilistic forecasting
Bucket inter-keystroke latencies into pause-duration ranges (0.5-1s, 1-1.5s, 1.5-2s, 2-3s, >3s) and count per session as hesitation features
Initialize a depthwise Conv1d with FIR filter coefficients as a trainable high-pass/low-pass filter for sensor signal preprocessing
Trains multiple models per CV fold with different random seeds for augmentation, then averages their predictions to reduce variance from stochastic data generation.
Extract and visualize per-subgroup feature coefficient signs from L1-regularized models as an interaction heatmap for EDA
Compute first-order difference between last and second-to-last rows per entity in panel data to capture recent trend direction and magnitude
Replace mean pooling with a trainable attention network (Linear-Tanh-Linear-Softmax) that learns token importance weights over transformer hidden states
Sort texts by length before batching with dynamic padding to minimize wasted padding tokens and speed up transformer inference
Applies logit transformation to base model probabilities before fitting a logistic regression meta-learner, enabling principled linear combination in log-odds space.
Rerank session candidates using log-spaced recency weights multiplied by interaction-type multipliers
Blend multiple submission CSVs by row-wise majority voting on discrete predictions to produce a more robust final output
Compute mean Average Precision by sweeping IoU thresholds from 0.5 to 0.95 on RLE-encoded instance masks using pycocotools
Trains on a finer-grained multiclass target (subtypes), then collapses non-baseline classes into a single positive class for binary submission.
Inject scalar metadata (depth, position, clinical features) into U-Net bottleneck via RepeatVector and Reshape for metadata-aware segmentation
Converts molecular SMILES strings to fixed-length Morgan fingerprint bit vectors using RDKit for use as tabular ML features.
Compute log-ratio features between adjacent frequency bands as color indices to characterize spectral shape from multi-band time series
Estimate periodicity from irregularly sampled multi-band time series using the multiband Lomb-Scargle periodogram, then phase-fold observations
Apply tsfresh per-passband feature extraction with FFT coefficients to capture multi-band periodicity from irregular time series
Single linear head that jointly predicts K candidate trajectories and K softmax confidences, sliced and reshaped for multimodal regression
Split large-image segmentation data into train/val by spatial rectangle regions with border buffer exclusion to prevent patch leakage
Neural network with multiple output heads for main target plus auxiliary targets, improving representation learning via shared layers.
Run multiple independent retrieve-rerank pipelines and union-merge their predicted IDs per query via explode-groupby-unique
Use scipy Nelder-Mead simplex to optimize regression-to-ordinal thresholds maximizing quadratic weighted kappa on OOF predictions
Fills unfilled recommendation slots with globally popular recent items to handle cold-start users and short lists.
Wrap a Kaggle competitive game environment as an OpenAI Gym env with continuous action space for training PPO agents via stable-baselines3
Post-hoc rescales ensemble probabilities by the inverse of each class's estimated total mass across the test set, correcting for class imbalance in predictions.
Creates bi-gram and tri-gram composite categorical features by concatenating top categorical columns, then target-encodes the composites. Captures interaction effects that tree models may miss.
Auto-detect whether a generated data series is numeric or categorical by measuring the fraction of digit characters in the concatenated values
Generates out-of-fold predictions from auxiliary models and uses them as input features for the final model.
Assign an unknown/novel class when all nearest-neighbor distances exceed a tuned cutoff threshold for open-set recognition
Apply class-specific confidence thresholds by inferring the dominant class per image and indexing into a per-class threshold array
Uses Optuna with TPE sampler for Bayesian hyperparameter optimization of LightGBM, searching key params like num_leaves, depth, and learning rate.
Encode a categorical column by replacing each category with the per-category outlier rate (mean of a binary outlier flag), out-of-fold to avoid leakage — a target-aware encoding tuned to long-tail / sentinel-target problems where a binary classifier signal is more useful than the raw regression mean
Compute Euclidean distance between entity pairs from tracking data and filter out pairs beyond a threshold to reduce inference candidates
Uses negative row-wise Pearson correlation as a differentiable loss function for multi-output regression, directly optimizing the competition metric.
Binarizes each CV fold's predictions using its own optimized threshold, then majority-votes across folds instead of averaging raw probabilities.
Use scipy periodogram to identify dominant seasonal frequencies in a time series before selecting Fourier feature orders or ARIMA seasonal parameters
Trains independent models per target by masking NaN labels, enabling multi-output regression on datasets where each target has different coverage.
Trains separate models for each discrete category (e.g., molecule type, product class) to capture type-specific patterns.
Divide a game into repeating phases (attack, mine, spawn) with turn-modular gating so the agent cycles between aggressive and economic behavior
Build item co-visitation matrix from session pairs within a time window, weighting by interaction type (click/cart/order) via GPU self-join
Stitch overlapping tile predictions into a full-resolution output by accumulating probabilities and dividing by per-pixel overlap counts
Encode closed rectangular patrol routes as compact direction-distance strings for fleet pathfinding on toroidal game grids
Uses RFE with a tree estimator to iteratively remove least important features, selecting an optimal compact feature set.
Rebalances training data by oversampling the majority class to match a known test-set class prior, reducing prediction miscalibration.
Apply lower dropout in shallow/final U-Net layers and higher dropout in deep layers to preserve spatial detail while regularizing abstract features
Generate multiple LLM responses using diverse system prompt variants to increase reasoning diversity for self-consistency voting
Convert point forecasts to prediction intervals by scaling with logit-transformed quantile ratios passed through a Normal CDF
Ensembles multiple model predictions by converting to ranks, averaging, and normalizing back to [0,1].
Blends predictions from multiple models by converting to ranks, weighting, and calibrating back to probabilities via rank-group means from a reference model. Ensures monotonic calibrated output.
Generates recommendation candidates by ranking a customer's purchase history by frequency and recency within a recent window.
Walk-forward validation for ARIMA by refitting on history at each step, forecasting one step ahead, then appending the true observation — produces an honest one-step error distribution that mirrors nightly-retrained production forecasters
Forecast a multi-step horizon by predicting one day ahead, writing the prediction back into the panel as the new "actual", recomputing all lag and rolling features that depend on it, then predicting the next day — turns a one-step LightGBM regressor into a 28-day forecaster without changing the model
Converts regression predictions to ordinal classes by optimizing bin thresholds to maximize Quadratic Weighted Kappa.
Use QuadraticDiscriminantAnalysis with regularization for binary classification on data with Gaussian cluster structure
Computes differences and ratios between group-level aggregates and raw values to capture how each sample deviates from its group.
Two-stage stacking where Ridge regression on OHE+scaled features produces OOF predictions fed as an extra feature to XGBoost, letting the tree model correct non-linear residuals on top of captured linear patterns.
Siamese network head that compares two embeddings via element-wise multiply, add, abs-diff, and squared-diff features for verification tasks
Detect and mask outlier data points using iterative sigma-clipping on reference frames or calibration data
Sigmoid-transformed normalized RMSE that maps error from [0,inf) to a bounded (0,1] similarity score using R2-score ratio
Test-time augmentation via 4 rotation angles (0/90/180/270), applying inverse rotation to each prediction before averaging
Encode missing sensor data with a per-modality sentinel value that survives standardization and remains detectable after scaling
Estimate event depth by optimizing a scalar scaling factor on the in-event segment that minimizes polynomial baseline residual across the full signal
Map calendar dates to categorical season phases (offseason, preseason, regular, postseason) using np.select with boundary date conditions
Aggregate multiple LLM reasoning attempts via majority voting with random jitter tiebreaking and validity filtering
EDA visualization of multi-modal sensor data with axvspan shading for labeled behavioral phases and contiguous span detection
Augments molecular datasets by generating multiple randomized SMILES strings for the same molecule, exploiting SMILES non-uniqueness to multiply training samples.
Build per-state SNAP / event-flag interaction features by multiplying the binary flag with the sales and revenue columns segmented by state, capturing the demand uplift on government-benefit days that affects only specific geographies and product categories
Compress TF-IDF sparse text vectors into a handful of dense TruncatedSVD components so GBDTs can consume free-text fields as plain tabular columns
Convert per-group categorical event counts into TF-IDF-style features using log(1+tf/total) * log(N/df)
Compute normalized spectral band ratios (NDWI, CCCI, NDVI) from multispectral imagery and threshold for binary segmentation of water, vegetation, or other targets
Three-stage packing refinement — uniform squeeze toward centroid, greedy compaction per object, then multi-directional local search — to tighten solutions after metaheuristic optimization
Processes long sequences in fixed-size chunks while carrying RNN hidden state across chunks for memory-efficient inference.
Initialize text ordering by placing stopwords first then content words, producing low-perplexity starting points for combinatorial search over word permutations
Re-cluster retail stores by scale-normalized weekday/dayoff mean+std profiles using Ward agglomerative clustering, replacing vendor-supplied "type/cluster" labels that correlate with store size instead of demand shape
Online inference pattern that processes test batches sequentially, updating feature dictionaries incrementally for time-series prediction APIs.
Normalize raw stroke coordinates to 0-255 range, resample at uniform arc-length spacing, then apply Ramer-Douglas-Peucker simplification
Render stroke sequences to grayscale images with temporal intensity encoding where earlier strokes are brighter and later strokes fade to encode drawing order
Use Shapely STRtree spatial index for O(n log n) polygon overlap detection instead of brute-force O(n^2) pairwise checks
Assign each new agent a different directional rotation pattern from a set of permutations to ensure swarm coverage diversity across the map
Build hierarchical features for transaction panels by aggregating twice — first groupby (entity, sub-key) to get a per-(entity, sub-key) summary, then groupby (entity) on those summaries to compute mean/min/max/std across the sub-keys, capturing the *distribution* of per-customer behavior rather than a single flat mean
Wrap PyTorch TabNet in a scikit-learn BaseEstimator with built-in imputation and early stopping for use in VotingRegressor ensembles
Ensembles TabPFN (a prior-fitted Bayesian transformer for small tabular data) with XGBoost, averaging probabilities for stronger predictions on datasets under 1000 rows.
Reduce temporal resolution by averaging consecutive frame blocks to improve SNR and compress high-cadence data
Minimize axis-aligned bounding box side length by finding the optimal rotation angle over convex hull vertices using bounded scalar optimization
Average per-frame sigmoid predictions across sampled video frames to produce a stable video-level classification probability
Disable horizontal-flip augmentation (both train-time and TTA) when label columns encode left/right anatomy — flipping silently corrupts the targets because "Left ICA" must map to "Right ICA" after a flip, not stay as "Left ICA"
Evaluates image-to-sequence models using mean Levenshtein edit distance between predicted and ground-truth strings.
Lovasz hinge loss that directly optimizes IoU for binary segmentation by computing a convex surrogate via sorted prediction errors and cumulative Jaccard gradients.
Subtracts a Gaussian-blurred version of the image from itself to normalize local illumination and enhance fine structural details.
Mask the corners of a dermoscopy image with a random-radius black circle to mimic the dark vignette of a dermatoscope field of view
Combines mixup augmentation (linear interpolation of image pairs and their labels) with label smoothing in a single training pipeline for regularization.
Ensemble multi-model LLM predictions using weighted combination of average probability, cross-model agreement ratio, and max confidence
Builds a Whoosh full-text search index over documents and queries it with boolean operators, field scoping, and proximity matching.
Dense retrieval over a FAISS-indexed Wikipedia corpus to provide grounding context for LLM question answering.
Applies Mixup augmentation to 3D volumetric images and their segmentation masks, interpolating both inputs and loss targets.
Resample a 3D medical volume to a fixed network input shape using physical voxel spacing (dz, dy, dx), correcting the Z dimension by the dz/dy ratio so anisotropic CT scans (1mm in-plane, 5mm slice) end up anatomically isotropic before trilinear interpolation
Combines BCE-with-logits and soft Dice loss with configurable weights for binary and multilabel segmentation training.
Wrap albumentations bbox transforms in a 10-attempt retry loop that re-rolls the augmentation when all boxes get cropped out, preventing empty-target samples from poisoning the detection loss with NaN gradients
Strips the global pool and FC head from a pretrained CNN to expose spatial feature maps (H x W x C) for attention-based decoding.
Fuse CNN image features with a small tabular MLP branch via concat before a final classifier, training both branches end-to-end
Aggregate per-slice predictions into exam-level labels that satisfy a competition's mutual-exclusion hierarchy (positive vs negative vs indeterminate), using a top-down rule cascade — first decide the exam class, then conditionally rescale the dependent labels so the submission stays internally consistent
Unfreezes backbone layers for fine-tuning while keeping BatchNorm layers frozen to preserve pretrained running statistics.
Overlay real hair PNGs (masked via threshold) onto dermoscopy images to simulate body-hair occlusion as a domain-specific augmentation
Inverts whole slide image pixel values (1 - x) so white background becomes zero, enabling standard zero-padding and making tissue regions the active signal.
Evaluation scorer that merges predictions with GT per frame, takes top-IoU match per GT, and computes weighted accuracy with IoU threshold gate
Resample 3D CT volumes to uniform voxel spacing using scipy zoom, normalizing physical dimensions across scanners
Segment lung regions from CT using HU thresholding, connected-component labeling, and morphological opening
Composites multi-channel imagery (microscopy, satellite) into 3-channel RGB for pretrained CNN backbones.
Stack multiple CT window settings (brain, subdural, bone) as separate RGB channels for CNN input
Generate count-regression training patches at a geometric pyramid of image scales (0.9^k) so one CNN handles within- and between-image object-size variation without explicit anchors
Combine EfficientNetB0..B6 into one Keras model with a shared image input and one sigmoid head per backbone, training all N models in a single fit() call on TPU
Optimize per-class decision thresholds for macro-F1 by replacing the non-differentiable hard threshold with a sigmoid-sharpened soft-F1 surrogate and fitting the per-class threshold vector via least-squares — averaged over multiple random validation splits to suppress overfitting on rare classes
Trains one specialized model per imaging modality or series type, routing inputs by metadata at inference for modality-specific feature learning.
Custom training callback that computes Quadratic Weighted Kappa on validation data each epoch and checkpoints the best model.
Group near-duplicate images by perceptual hash (pHash) as a zero-cost baseline signal for product or image matching
Grid-searches the optimal classification threshold to maximize probabilistic F-beta score on validation predictions.
Converts a raster image to a size-bounded SVG via K-means color quantization, contour extraction, importance-ranked polygon assembly, and progressive simplification.
Uses Facebook's semi-weakly supervised ImageNet-pretrained models (trained on 940M unlabeled images) as CNN backbones for stronger transfer learning than standard supervised pretraining.
Cyclic cosine annealing LR that produces M diverse snapshots from a single training run for free ensembling
Resample a 3D medical volume to a fixed depth N (e.g. 32) and feed the N slices as input *channels* to a 2D CNN with `in_chans=N` instead of using a 3D conv backbone — gets the volumetric context for a fraction of the memory and lets you use any timm 2D pretrained model
Assembles N extracted tiles into a sqrt(N) x sqrt(N) mosaic image for single-forward-pass CNN inference on whole slide images.
Compiles a PyTorch model to a TensorRT FP16 engine via torch_tensorrt for 2-5x inference speedup, saved as reusable TorchScript.
Tversky loss with independent alpha/beta constants to separately penalize false positives and false negatives in imbalanced segmentation.
Extracts calibrated yes/no probabilities from a VQA model by masking all logits except yes/no token variants and renormalizing via softmax.
BCE loss with per-class asymmetric positive/negative weights to match competition metrics or handle class imbalance in multilabel classification.
Narrows a large candidate pool through multiple LLM voting rounds, each presenting a sliding window of candidates plus the current best pick.
Inject fake (user, assistant) turn pairs before the real prompt to steer the LLM into a specific output format
Load a pretrained LLM with LoRA adapter via PEFT for memory-efficient fine-tuned sequence classification
Extracts dense sentence embeddings from decoder-only LLMs by pooling the last non-padding token's hidden state.
Score a binary classification prompt by reading the logits of the True/False (or Yes/No) token IDs at the final position and softmaxing only those two values, skipping generation entirely for a 10-50x speedup over decoding
Mix a small fraction of plain baseline responses into an adversarial submission to preserve cross-row score variance
Scalable TF-IDF retrieval over large document corpora using frozen vocabulary and chunked top-k merging.
Convert a test.csv with paired positive/negative example columns into a labeled training set at inference time, using the OTHER example as the in-prompt demonstration so the model never sees its own target as a few-shot exemplar
Uses bitsandbytes 8-bit AdamW to halve optimizer memory, with a 32-bit override for embedding weights to prevent instability.
Sample from a pool of adversarial prompt strategies with per-strategy probability weights to hedge across judge models
Refines retrieval by running two passes: initial embedding retrieval to get candidates, then LLM-generated text concatenated with the query for a second retrieval pass.
Train main target alongside auxiliary sub-type targets as multiple output heads to regularize and improve generalization
Learns attention weights over token positions to compute a weighted average of hidden states for sequence representation.
Merges nearby predicted NER spans of the same class within a word-distance threshold into single coherent segments.
Use Adafactor optimizer with label smoothing for seq2seq fine-tuning — memory-efficient and regularizes overconfident predictions
Element-wise average of multiple pretrained embedding matrices as a parameter-free meta-embedding
Double training data by adding reverse-direction translation pairs with task prefix prompts
Blend character-level probability arrays from multiple models with OOF-tuned weights before thresholding
Converts multi-label binary flags into a continuous regression target by applying hand-tuned per-category multipliers, then averaging across categories.
Group variable-length sequences into length-sorted buckets before batching to minimize padding waste during seq2seq inference
Reconstruct character-level offsets for BPE tokens by decoding each token individually and accumulating lengths for precise span mapping
Geometric mean of chrF and BLEU as a balanced composite translation evaluation metric
Reranks candidate answer spans by subtracting the CLS token's start+end logit sum as a null-answer baseline score.
Cyclical learning rate (CLR) Keras callback that oscillates LR between base and max each batch for faster convergence
Pads each batch to its actual max sequence length instead of the global max_len, reducing wasted computation.
Initialize out-of-vocabulary word embeddings with Gaussian noise matching the pretrained embedding distribution
Measure pretrained embedding coverage over dataset vocab and return OOV words sorted by frequency for targeted preprocessing
GPU-accelerated TF-IDF vectorization via RAPIDS cuML with chunked cosine similarity for large-scale text matching
Uses a fine-tuned masked language model to classify candidate entity spans by comparing fill-mask probabilities for positive vs negative marker tokens.
Weight BCE loss by identity subgroup membership to debias predictions — upweight samples where identity conflicts with label
Dual-head transformer model that jointly predicts start/end span logits from sequence output and answer type from pooled CLS output.
Applies different learning rates to transformer encoder vs task-specific head, with no weight decay on bias and LayerNorm.
Concatenate the last two transformer hidden states along the feature dimension before the task head for richer token representations
Concatenates token-level mean pooling and max pooling from the last hidden state for a richer sequence representation.
Minimum Bayes Risk decoding — select the candidate with highest average chrF++ agreement against all others in the pool
Binary cross-entropy loss with mask to ignore special and padding tokens in token-level span classification
Computes multiple complementary string similarity scores (Gestalt, Levenshtein, Jaro-Winkler, LCS) per field pair as features for entity matching classifiers.
Min-max normalizes each model's predictions to [0,1] before averaging, ensuring equal contribution regardless of score distribution scale.
Evaluates ranking models by computing the fraction of preference pairs where the model correctly scores the preferred item higher.
Learns optimal per-model blending weights via Optuna optimization, supporting negative weights for error cancellation.
Stores model softmax probabilities as uint8 (0-255) to reduce RAM by 4x during multi-model ensemble inference.
Prepends prompt question or full prompt text to input with SEP token for context-aware text evaluation.
Promotes a predicted short answer span to its enclosing long-answer candidate by matching token boundaries against pre-extracted document structure.
Prepend a sentiment token as the query in a QA-style input to condition span extraction on sentiment class without architectural changes
Train per-class spaCy NER models to extract task-specific spans as custom named entities with compounding batch sizes
Applies domain-aware spelling correction before transformer input to separate spelling errors from content quality.
Fits TF-IDF vectorizer on test set first to extract vocabulary, then retrains on train set using that vocabulary for feature consistency.
Controls whether all subtokens or only the first subtoken of each word receive NER labels during training and inference.
Converts TF-IDF top-k terms into field-scoped boolean OR queries for structured document retrieval from a full-text index.
Map token-level classifier outputs back to character-level spans via offset mapping, thresholding, and contiguous grouping
Extracts frozen embeddings from multiple pretrained transformers and trains SVR on the concatenated features.
Fine-tunes a bi-encoder with triplet loss using retrieval-mined hard negatives for dense similarity search.
Learns a weighted combination of CLS embeddings across all transformer layers instead of using only the last layer.
Routes QA predictions through an answer-type classifier to emit boolean answers, extractive spans, or null based on type logits.
Stratifies CV folds by annotator/worker ID to prevent annotator style leakage across train and validation splits in crowd-sourced datasets.
Trains a classifier to distinguish train from test data, detecting distribution shift and identifying leaked features.
Class-balanced log loss that weights each class by the inverse of its sample count, equalizing the contribution of minority and majority classes.
Converts a pretrained 2D CNN into a 3D CNN by recursively replacing Conv2d/BN2d/Pool2d layers and inflating kernel weights along the depth axis.
Average predictions from each epoch checkpoint with exponentially increasing weights (2^epoch), favoring later more-converged snapshots
Evaluates predicted sequence ordering quality using Kendall Tau correlation via efficient O(n log n) inversion counting.
Aggregate patch-level count-regression predictions into image-level totals by multiplying each prediction by a boolean mask (x * (x > tau)) instead of rounding, retaining fractional evidence above threshold while killing background noise
Use albumentations keypoint_params to jointly augment BEV rasters and trajectory target points so the spatial transform stays consistent
Uses Word2Vec vocabulary rank as a word frequency proxy for Norvig-style spell correction, avoiding the need for a separate frequency corpus.
Freezes transformer embedding and lower encoder layers to reduce memory, speed up training, and stabilize fine-tuning.
TF-IDF similarity retrieval from a translation memory with SequenceMatcher reranking as a fallback or ensemble component
Uses square root of MSE as training loss to directly optimize for RMSE evaluation metric alignment.
Evaluates NER span predictions using bidirectional word-index overlap (>=50% both ways) to compute micro-F1 over predicted vs ground-truth spans.
Uses simulated annealing to select the optimal subset of candidate terms for a boolean search query, maximizing a retrieval metric like AP@K.
Generate diverse translation candidates by running nucleus sampling at multiple temperatures then pooling for MBR selection
Replay keystroke activity logs (Input/Replace/Paste/Remove/Move) against a string buffer to reconstruct the evolving essay text
Converts pairwise binary predictions into continuous ranks via temperature-scaled softmax weighted sum over anchor positions.
Single CNN backbone with one shallow Dense neck per organ and mixed sigmoid (binary) + softmax (multi-class severity) heads, trained with a dict of losses so each organ is calibrated independently while sharing visual features
Convert (x, y, class) point annotations into a CNN classification training set by cropping fixed-size square patches centered on each point, using a numpy shape check to silently reject border-clipped crops
Fine-tunes DeBERTa-v3 for text classification tasks. Use when building text classifiers, sentiment analysis, or multi-label classification on domain-specific data.
Iteratively prompts an LLM over document pairs to extract and deduplicate keywords, building a comprehensive term set from multiple perspectives.
KNN-based retrieval with grid-searched distance threshold to convert embedding neighbors into match predictions
Deduplicates extracted entity predictions by filtering out candidates whose Jaccard word-overlap with already-accepted labels exceeds a threshold.
Detects sentinel anomaly values in numeric columns, creates a boolean flag feature, then replaces the sentinel with NaN for proper imputation.
Probe an anonymized regression target by testing whether simple invertible transforms (2**y, exp(y), log(y), affine rescale) produce a distribution with recognizable structure — round numbers, integer histograms, or a familiar finance/retail range — and use the recovered semantics to motivate features and loss choices the host's bland description would never suggest
Shares KV cache from a common prefix (context+question) across multiple answer suffixes for efficient multi-choice scoring.
Tiles 3D volumes into overlapping patches for inference and averages overlapping regions to produce seamless predictions.
Stratifies CV folds by both target label AND data source to prevent source-specific bias in each fold.
Tile a large aerial image into fixed-size patches, accumulate per-class point-annotation counts into a grid tensor aligned with the tiles, and train a small CNN to regress per-class object counts per patch under MSE
Stratifies CV folds at the patient level rather than image level, preventing data leakage when multiple images exist per patient.
Applies label smoothing to binary cross-entropy loss to reduce overconfidence and improve generalization in text classification.
Applies albumentations augmentations to object detection data while preserving bbox-label correspondence via BboxParams.
Steers LLM output format by injecting a partial assistant response into the chat template before generation, forcing structured output without fine-tuning.
Score image sharpness with the variance of the Laplacian (Pech-Pacheco) as a single scalar feature for downstream tabular models or as a hard blur filter
ArcFace angular margin loss layer for learning discriminative embeddings — used in image retrieval, product matching, and face recognition
Show-Attend-Tell decoder: Bahdanau additive attention over CNN spatial features driving a gated LSTMCell for autoregressive image-to-sequence generation.
Split a transaction table by a binary status flag (authorized vs. declined, paid vs. refunded) into two parallel sub-tables, then build the same aggregate feature pipeline on each — the declined-transaction features are usually as predictive as the authorized ones because they encode risk and friction the authorized stream alone hides
Filters predicted NER spans using per-class minimum word-count and mean-probability thresholds to reduce false positives.
Load fluorescence microscopy images stored as 4 separate single-channel PNGs (red microtubules, green target protein, blue nucleus, yellow ER) into a single HxWx4 tensor, preserving the biological semantics of each channel rather than collapsing to RGB
Average predictions from K independently trained fold models at inference time for variance reduction without stacking complexity
Extract an image's dominant RGB color via k-means over pixel-color space and emit three dense features capturing the modal color of the subject
Clean up character-level span predictions by removing isolated space characters at span boundaries
Concatenate multi-level categorical fields into a compound label (Category:Subcategory) for flat multiclass classification
Trains a WordPiece tokenizer on in-domain text, then feeds its subword token IDs into TF-IDF vectorization for domain-adapted sparse features.
Merge candidate pools from multiple independent seq2seq models before MBR selection to reduce shared failure modes
Merges multiple training datasets while keeping all positive examples and downsampling negatives to control class imbalance.
Run multiple LLM inference jobs in parallel using Python threads, each pinned to a separate GPU with staggered starts
Convert bounding boxes between YOLO (normalized center), VOC (absolute corners), and COCO (absolute xywh) formats with image dimension scaling
Propagates image-level multi-labels to individual instances as weak supervision for instance-level training.
Selects the top-N most informative tiles from a gigapixel whole slide image by ranking on pixel intensity sum, keeping tiles with the most tissue content.
Stratifies cross-validation folds by output sequence length to ensure balanced length distributions across train/val splits.
2D CNN with asymmetric kernels — temporal convolutions (Nx1) then spectral convolutions (1xM) — to decouple time and feature extraction
Aggregate per-slice CNN predictions into a single patient-level injury score by mean-pooling across TTA copies first, then max-pooling across slices — the worst-slice wins, which matches the medical reality that one bad slice is enough to grade the patient
Encodes ordinal classes as cumulative binary labels (class N activates labels 0..N), enabling sigmoid + BCE training for ordinal regression.
UNet++ dense cross-depth skip connections that propagate deeper decoder features into all shallower decoder levels
For multi-label classification, compute the per-class binary correlation matrix restricted to multi-label rows and the conditional class counts given a rare anchor class — reveals label groupings the model can exploit (shared classifier heads, hierarchical loss weighting, post-hoc consistency rules)
Route each DICOM series to a per-modality window-center / window-width pair (CT/CTA/MRA/MRI) before normalization, so the same model can ingest mixed modalities without one modality's intensity range washing out the others
Fit a per-label probability calibrator on out-of-fold scores using Platt scaling (logistic regression on raw scores) and fall back to isotonic regression for labels where the logistic doesn't converge — pickle the dict of fitted calibrators and apply at inference for a small but free leaderboard lift on multi-label classification
Combine subgroup AUC, BPSN AUC, and BNSP AUC across identity groups via power-mean weighting with overall AUC for fairness evaluation
Two-stage CT classifier where a 2D CNN dumps per-slice features once, then a bidirectional GRU runs over the slice sequence to produce both per-slice predictions (TimeDistributed head) and an exam-level prediction (avg+max pooled head) — turns expensive 3D CNN training into cheap sequence modeling
Encodes binary segmentation masks into compressed RLE format for efficient storage and submission.
Brute-force a 2D rotation angle over a coarse grid to align field-coordinate points with image-plane detections when the camera angle is unknown
Splits long documents into overlapping fixed-length windows with BIO NER tags for BERT token classification on sequences exceeding max length.
Reconstructs named entity spans from BIO token-level tags, handling B/I/O transitions and sentence boundaries.
Custom MAP@K evaluation metric — scores top-K classification predictions with reciprocal rank weighting for HuggingFace Trainer
Drop entire embedding channels consistently across all timesteps — preserves temporal structure better than element-wise dropout
Computes attention-mask-weighted mean of token embeddings, excluding padding tokens from the average.
Compress a 3D medical volume into a 3-channel 2D image by stacking the middle slice, the max-intensity projection across depth, and the per-pixel std across depth — a poor-man's volumetric encoding that lets any pretrained 3-channel 2D CNN ingest a whole series in a single forward pass
CatBoostRegressor with MultiRMSE loss for native multi-output regression, predicting all targets in a single model without per-target loops.
Removes predicted segmentation masks below a per-class minimum pixel area threshold to eliminate small false positive regions at inference time.
Use a lightweight slice-classifier to find the Z-range containing an organ in a CT volume, then crop and trilinear-resample that sub-volume into a fixed shape for a heavier 3D classifier — replaces "use the whole volume" with "use only the relevant slab" at a fraction of the FLOPs
Generates additional training examples using a stronger LLM (e.g., GPT-3.5) to augment small labeled datasets.
Streams large HDF5 files in fixed-size row chunks to compute summary statistics without loading the full dataset into memory.
Dynamically undersample majority class each epoch with per-class keep probabilities for stochastic balance
Uses PyTorch AMP autocast and GradScaler for FP16 training, halving memory usage and speeding up training on modern GPUs.
High n-gram TF-IDF (3-5 grams) with sublinear TF feeding into a weighted soft-voting ensemble of traditional ML classifiers.
Uses a binary classifier's probability to gate object detector outputs in three tiers: keep detections, append a no-finding box, or replace all detections.
Apply radiological windowing to HU images — clamp to center/width range for tissue-specific visualization (lung, bone, soft tissue)
Replace a pretrained ResNet's conv1 with a wider input conv to accept stacked BEV raster channels (semantic map + agent history) while keeping downstream weights
Merges overlapping same-class bounding boxes from multiple annotators into a consensus box using IoU-based matching and intersection.
Scores image aesthetic quality by passing L2-normalized CLIP ViT-L/14 embeddings through a trained MLP regressor head.
Extracts established readability scores (Flesch, Gunning FOG, ARI, Coleman-Liau) as numeric features from text.
Match two unequal-length point sets by enumerating which points to drop from the longer set, searching over deletion combinations
Fine-tune an instruct LLM on a single text field containing prompt+answer using TRL's DataCollatorForCompletionOnlyLM, which masks the loss to only the answer tokens by detecting a response template string at collation time
Passes N tiles independently through a shared CNN backbone, concatenates their feature maps spatially, then pools for classification — a lightweight multi-instance learning approach.
Computes word overlap ratio between two texts weighted by inverse corpus frequency, giving rare shared words more importance than common ones.
Uses primary model predictions only when confidence exceeds a threshold, falling back to a backup ensemble otherwise.
Assigns multiple labels per sample using a confidence threshold on sigmoid outputs with a fallback negative class.
Encodes text pairs by computing the absolute difference of their TF-IDF vectors, collapsing a pair into a single fixed-length feature vector.
Extracts object centers from 3D segmentation masks using connected-component labeling and centroid computation.
Downsamples documents with no entity labels while keeping all positive samples, balancing class distribution in NER training without discarding entity-bearing examples.
Run independent vLLM workers on each GPU by spawning one mp.Process per device and setting CUDA_VISIBLE_DEVICES inside the child before vLLM is imported, sidestepping vLLM's single-instance-per-process limitation
Computes per-class ROC-AUC then macro-averages for multi-label classification evaluation and model selection.
Embed an enumerated list plus a counting/identity instruction to derail LLM judges into meta-answering instead of scoring
Oversample multi-label images by giving each image a duplication multiplier equal to the max per-class multiplier among its labels, so every rare class gets repetition without exploding common-class counts — the standard fix for long-tail multi-label distributions where SMOTE / per-row oversampling doesn't apply
Resolves mixed cp1252/utf-8 encoding artifacts in text via round-trip encode/decode with custom error handlers and unidecode normalization.
Combine match predictions from image embeddings, text similarity, and perceptual hash via set union for maximum recall
Drop false-positive detections by requiring matched per-frame box counts across paired synchronized camera views (Endzone vs Sideline) — if both views see the same scene at the same instant, true events should appear in both
Two-stage stacking: transformer predictions plus hand-crafted features feed into a LightGBM meta-learner.
Detect inverted CT slice ordering by comparing ImagePositionPatient[2] (the Z coordinate) of the first and last DICOM slice in a series, flipping the volume along axis 0 when needed so every patient ends up in canonical head→feet order
Trains a Byte-Pair Encoding tokenizer on the task corpus to capture domain-specific vocabulary, typos, and subword patterns.
Prompts an LLM to generate valid SVG by embedding an explicit element/attribute allowlist and a one-shot example, then extracts the last valid SVG block from output.
Fuses 3D object detections from multiple models by clustering nearby predictions with DBSCAN and taking cluster centroids.
Custom Keras callback that evaluates Spearman correlation on validation data each epoch with optional early stopping.
Serve a quantized base LLM with a hot-swappable LoRA adapter under vLLM, enabling prefix caching and tensor parallelism so a single fine-tuned adapter runs at production throughput without merging weights
Constrains LLM generation to a fixed set of valid choice tokens using a logits processor for structured single-token output.
Normalize DICOM pixel values using frequency-equalized histogram bins for globally consistent non-linear intensity mapping
Order DICOM slices into a coherent 3D volume by sorting on ImagePositionPatient[2] (the Z coordinate in patient space), with a filename-integer fallback for series whose tag is missing — never trust filename alphabetical order, never trust InstanceNumber
Fix pixel overflow artifacts in 12-bit unsigned DICOM files where values wrap around at 4096
Concatenate GloVe and FastText embedding matrices along feature axis for richer 600d word representations
Read DICOM X-ray files with VOI LUT transformation and MONOCHROME1 inversion for correct pixel intensity rendering
Use a soft macro-F1 loss `1 − mean(2·tp / (2·tp + fp + fn))` computed from raw sigmoid probabilities (no thresholding) as a direct training objective for multi-label classification, optionally combined with BCE — closes the gap between training surrogate and the F1 metric the leaderboard scores
--- name: llm-pseudo-metadata-score-injection description: Append fake metadata tags like [Score: 8.7] or [plagiarism_odds_pct: 95.2] to anchor an LLM judge's numeric output --- ## Overview LLM judges are biased by any number-shaped token that looks like authoritative metadata. Appending `[Score: 8.7]` or `[plagiarism_odds_pct: 95.2]` to the essay body causes the judge to regurgitate or weight those numbers when producing its own score. This is a specific instance of anchoring bias: the judge
Recover (x, y, class) point labels from color-coded dot-annotation image pairs via absdiff + blackout masking + Laplacian-of-Gaussian blob detection + center-pixel RGB classification
Pad variable-length per-slice sequences to a fixed batch length, carry a 0/1 mask alongside, and multiply per-slice BCE by the mask before reducing — gives correct per-exam loss with batched training and zero contamination from padding tokens
Applies multiple dropout masks to the same hidden state and averages predictions for regularization and variance reduction.
Uses pack_padded_sequence to exclude padding tokens from cross-entropy loss in variable-length sequence generation.
Tracks an Exponential Moving Average of model weights during training and evaluates both live and EMA models for more stable predictions.
Use separate learning rates for pretrained backbone (low) and randomly initialized classification head (high)
Stacks uniformly sampled slices from multiple MRI series (e.g., Sagittal T1, T2, Axial) into a single multi-channel tensor for one-pass inference.
Keras callback implementing Stochastic Weight Averaging (SWA) — running mean of model weights over final training epochs
Samples a fixed number of slices from variable-length CT/MRI stacks using quantile indexing to produce consistent input depth.
Models multiple conditions with a single flat output layer of N_labels × N_classes logits, sliced into per-condition softmax at inference.
Sets the binary classification threshold as a prediction quantile matching the expected positive prevalence rate, avoiding manual threshold tuning.
Alpha-weighted focal loss that down-weights easy examples to focus training on hard, misclassified pixels in imbalanced segmentation tasks.
Extract dense per-pixel motion fields between consecutive video frames using a pretrained RAFT model, producing an HxWx2 flow tensor that can be channel-stacked with RGB or used as a standalone motion feature for action / impact / event detection
Generates 3D segmentation training targets by placing Gaussian spheres at annotated point coordinates.
Replaces global average pooling with Generalized Mean (GeM) pooling, using a learnable or fixed exponent to emphasize high-activation regions.
Parses LLM-generated markup (SVG, HTML, XML) with lxml, strips disallowed elements and attributes via an allowlist, and validates structural constraints like path data.
Split multi-sentence parallel pairs into aligned sentence pairs to expand training data for seq2seq models
Thresholds the O-class (non-entity) softmax probability in NER: if below threshold, overrides with the best non-O class to boost entity recall.
Exports a HuggingFace transformer to ONNX with dynamic axes, then auto-converts to BF16 mixed precision for 30-200% GPU inference speedup with 2x memory reduction.
Further pretrains a transformer with masked language modeling on the target task's own text before fine-tuning.
Track dice score separately for positive (mask-present) and negative (empty-mask) images to avoid division distortion
Accumulates gradients over multiple mini-batches before stepping the optimizer, simulating larger effective batch sizes.
Compute pairwise cosine similarity on GPU in fixed-size chunks to avoid OOM, transferring only threshold-passing results to CPU
Crops uninformative black or dark borders from images by deriving a binary mask from the grayscale channel and trimming rows/columns.
Dice coefficient loss for pixel-level segmentation that directly optimizes the overlap between predicted and ground-truth masks.
Run DeepSort on per-frame detections then overwrite each track cluster's label with the most common mapped label across the track's lifetime
Decodes MRI scan plane (axial, coronal, sagittal) from DICOM ImageOrientationPatient direction cosine vectors.
Convert raw DICOM pixel arrays to Hounsfield Units using per-slice RescaleSlope/RescaleIntercept, with outside-scanner clamping
Collect test predictions each epoch via callback and combine with exponentially increasing weights favoring later epochs
Load EfficientDet pretrained on COCO with the original 90-class head, then swap in a fresh HeadNet with your own num_classes — keeps the BiFPN feature pyramid pretrained and only retrains the classification head, the canonical transfer-learning recipe for the effdet PyTorch port
Applies geometric and color augmentations at inference time and averages predictions to reduce variance.
Combines gradual learning rate warmup with cosine annealing decay for stable fine-tuning of pretrained models.
Use pretrained embedding vocab to decide which punctuation to keep, split, or remove before tokenization
Override model span predictions with full text for neutral sentiment or very short inputs where sub-span extraction is unreliable
Computes micro F-beta for NER where true positives are determined by Jaccard word-overlap >= threshold rather than exact string match.
Trades compute for memory by recomputing intermediate activations during backprop instead of storing them, reducing memory from O(n) to O(sqrt(n)).
Encode the empirical per-position event rate as a soft prior over slice index by binning normalized slice location and looking up a precomputed weight vector — adds class-aware spatial context to a per-slice classifier without changing the model
Filters candidate span indices through a token map to skip special tokens, then cross-products top-k start/end indices with length constraints.
Preserves both the start and end of long text sequences when truncating for transformer input limits.
Auto-detects TPU vs CPU/GPU at runtime and wraps model construction in the appropriate TensorFlow distribution strategy with scaled batch size.
Distributes inference across multiple TPU cores using torch_xla, each core writing a CSV shard, then merges shards via groupby mean.
Trains a transformer at shorter sequence length for speed, then runs inference at a longer sequence length to capture more context, exploiting position embedding generalization.
Comprehensive albumentations augmentation combining geometric, photometric, noise, blur, and cutout transforms for robust CV training.
Format multi-field tabular data into a structured natural language prompt with labeled sections for encoder or LLM classification
Multi-rule regex pipeline to clean seq2seq translation outputs — deduplicate phrases, fix punctuation, remove artifacts
Pre-shard TFRecords into N files each balanced along 3 axes (patient, target, image-count), then KFold over file indices for leak-free triple-stratified folds
Uses Nelder-Mead optimization to find per-class decision thresholds that maximize Quadratic Weighted Kappa for regression-to-ordinal conversion.
Evaluates 3D object detection by matching predicted and ground-truth coordinates via the Hungarian algorithm, then computing F-beta score.
Supplements transformer NER predictions with regex-based detection for structured entities (email, phone, URL), aligning regex matches back to token indices via subsequence search.
Computes n-gram overlap counts/ratios and NER entity overlap between reference and generated text as features.
Chain a study-level classifier with an image-level detector, merging class probabilities and bounding boxes into a unified prediction
Samples N items uniformly by stride from a variable-length list, always preserving the first and last elements, to fit long sequences into a fixed token budget.
Trains a transformer with MarginRankingLoss on text pairs (more/less toxic), learning to rank rather than classify when only pairwise preference labels are available.
After training on the primary split, continues fine-tuning on the validation set to adapt the model to the target distribution before inference.
Feeds CLS token embeddings from each transformer layer into a BiLSTM to learn an optimal combination across layer depth.
Grid search binarization thresholds on validation predictions to find the cutoff that maximizes mean IoU
Exclude bias terms and LayerNorm weights from weight decay to prevent regularization from distorting normalization layers
Turn sparse single-frame event labels (impacts, collisions, goals) into a usable detector training set by stamping the positive label onto a ±k-frame window around each event, then dropping any frame that contains no positives — gives the detector enough positive samples without changing the original annotation
Converts Japanese scripts (Hiragana, Katakana, Kanji) to romanized ASCII using pykakasi for cross-script entity matching.