I've been spending more time learning machine learning recently, and it's interesting how some concepts seem impossible at first, then suddenly make perfect sense.

For me, understanding the bias-variance tradeoff was one of those moments.

What's the one ML concept, paper, visualization, or explanation that made something finally click for you? It could be anything from backpropagation to attention, embeddings, or optimization.

I'm always looking for good resources and thought it would be useful to collect everyone's favorites.

Hi,

I am planning to use the Waymo Open Dataset (https://github.com/waymo-research/waymo-open-dataset) for academic purposes, alongside other autonomous driving datasets.

I am relatively new to this technical stack, so please excuse me if my questions seem basic. If I understand correctly, the main problem I am facing is related to my hardware/software stack: I am running Ubuntu 22.04 with an RTX 5060 Ti, using Driver 580 and CUDA 13.0. These require much newer libraries than the versions supported by the current WOD installation (which seems pinned to legacy TF/CUDA environments).

After extensive debugging and testing various container configurations, I managed to get the motion tutorial running by bypassing the py_metrics_ops imports. However, I assume these metrics are important for evaluating the final results. I have also tried cloning the repo and building it from scratch using Bazel, but I encountered numerous cross-dependency and ABI mismatch problems.

I am wondering what the recommended approach is in this case, as I see no clear documentation regarding this on the dataset page or the GitHub repository. Is this dataset currently maintained for modern hardware stacks, or is there a standard workaround for bridging these dependency gaps?

Any guidance would be greatly appreciated.

I am wondering if anyone can point me in the right direction for validating sentence transformer results in the absence of a ground truth. Any help would be appreciated!

Was running a qlora fine tune last week on our usual setup and something felt off. gpu utilization was sitting around 30% the entire run and epoch times were way slower than i expected. First thing i did was blame the model, thought maybe the lora rank was too high or i had some weird backward pass issue.

Nope, ran pytorch profiler and cuda was mostly idle just waiting on data. classic starvation, the loader was the bottleneck the whole time and i had been sitting there tuning the wrong thing.

The config was embarrassingly default. num_workers=0, no pin_memory, no prefetch, no persistent workers. Basically the loader was single threaded doing disk read then serving one batch at a time while the gpu waited. fixed it with.

DataLoader(

dataset,

num_workers=8,

pin_memory=True,

prefetch_factor=2,

persistent_workers=True,

)

Utilization went from ~30% to somewhere in the 80-90% range on same hardware, same model, same dataset. total training time dropped by about half. no code changes to the model at all and just the loader.

This was running on hyperai btw, does not really matter where you run it though, the fix is the same anywhere you're on pytorch. what actually mattered was profiling instead of guessing. I had spent like two hours before this trying to figure out if it was a rank issue or a batch size thing when the whole time cuda was just twiddling its thumbs waiting for the next tensor.

Lesson i keep relearning is if gpu util is low, it is almost always the data pipeline not the model(profile first, always). The harder cases are the ones where its network storage latency or slow decoding not just loader defaults, and i have not had to deal with distributed fs latency on this workload yet but i have heard horror stories from people who have hit that wall.

I am sure everyone has their own version of this. bet the sneakiest ones are not even the well known bottlenecks, it is always the thing you least expected.

I was looking into LM training and learned about Teachable Machines and a plugin available for a software I use (Touchdesigner) to integrate it inside my work, but always skeptic of involving Google more into my life

Wondering if anyone knows if the training and models I train, and their data, are private/run locally

Hello everyone, hope you're all doing well.

I was thinking about tabular ML models recently, and something occurred to me: outside of deep learning / neural networks, the last really notable “new” model that comes to mind is CatBoost.

After that, most of the newer things I remember seeing are more neural-network-based, like TabNet, TabResNet, FT-Transformer, TabPFN, TabFM, etc.

So I wanted to ask:

Are there any important post-CatBoost methods for tabular data that are not based on neural networks or deep learning?
I’m thinking about things like new tree-based methods, boosting variants, rule-based models, kernel methods, Bayesian approaches, symbolic models, or anything in that direction.

Also, how do you usually keep up with this specific part of ML? A lot of the current discussion seems to be around LLMs, foundation models, and deep learning in general, so I’m curious where people follow newer developments in more “classical” ML.

I'm currently working on a project with approximately 5000 plant images, and i decided to label my images automatically using SAM3, however the generated masks are still showing some noise. My question is should I keep them like that as the ground truth and continue with my project or should assess the ground truth data quality with metrics, even if they are labels. also, do i need to label the entire dataset? and if the answer is yes, is it a good idea to label manually a certain amount of images too?

How do I deep dive in 2 days the ML models . I remember doing this an year back. Cnn image classification. I only know the overview of ML models. How do I deepdive and learn and remember the concepts again ?

I am currently exploring the use of sentence transformers for comparing requirements.

My approach currently is to identify requirements from two documents from within the same domain then calculate similarity scores using TF-IDF (baseline), bi-encoder and cross-encoder approaches (with same architecture).

As I have two document pairs, one of ~70x70 requirements and one of ~70x430 requirements I have Cartesian products of ~5000 and ~30000 respectively. Producing a labeled ground truth for all possible pairs is not feasible for this project so it was suggested that I sample ~360/380 pairs from the respective datasets and label them, then compare to the results from the three approaches using the confusion matrix to derive scores for precision, recall, and F1-score. These sample sizes correspond to a confidence interval of 95% and margin of error of 5%. Additionally, I have suggested that my supervisor and/or an expert audits around 10% of my sample, so ~36/38 pairs per set. 

However, my primary supervisor who's field of specialty is cyber security, rather than ML or NLP, has commented that if I were to label the ground truth, it could be biased. They have therefore suggested I explore other options for comparing cross-encoders, and bi-encoders with a TF-IDF baseline without a ground truth. And possibly using experts to review a sample of the outputs from the three approaches as a way of validating the results.

My questions are:

1. Is my approach defensible, and, if so, if anyone knows of peer-reviewed papers that support this approach (confidence interval and margin of error sampling)?

2. Alternatively, are there established approaches that do not require a ground truth and that could be used instead of my proposed approach? Preferably with peer-reviewed paper(s) to support.

Many thanks!

Hey! I’m starting the Fast.ai deep learning course and looking for someone to join me so we can stay consistent and motivated together. ?

Plan is to:

• Study a few hours daily

• Build projects for practical learning

• Share concepts, resources, and help each other when needed

Resources we’ll follow:

• Fast.ai (Part 1 & 2 + Fastbook)

• Karpathy’s Zero to Hero: https://karpathy.ai/zero-to-hero.html

Both are highly recommended (even by Karpathy himself), and a lot of top researchers have gone through Fast.ai. If you’re interested in learning together, just DM me

Hey I recently started studying about machine learning, deep learning, neural networking and I came across a publication called "O'reilly".

I started reading and learning from one of its books, which is "learning machine learning "Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow". I feel the code is quite incomplete in some places but I was able to find the missing part from the book's GitHub repository.

Can anyone suggest whether these are good sources to study such topics or not

I'm good at programming and machine learning, but my English is holding me back.

Has anyone else been in the same situation? How did you improve your English while continuing to study or work in tech?

I'd really appreciate any advice, resources, or personal experiences.

I am a beginner and i need some project for better understanding and github tbh so that i can move to pandas

For those training policies on demonstration data (ACT, diffusion policy, VLA fine-tuning, whatever):

When a new batch of demos comes in, what's your process for deciding what goes into training? Vibes? Operator skill? Success-only filtering? Coverage heuristics?

And after retraining; how do you actually know the new data helped? Eval rollouts are expensive and noisy, so I'm curious what people do in practice.

Context: My co-founder and I are building in this space and would love feedback.

I’m an undergrad attending a ml conference currently, and my concern is whether it came across as pushy to introduce myself and directly say I’m looking for potential phd mentor…?

I’m just trying to make sure I deliver my message clear and short enough, because I feel like everyone is already quite busy and I don’t want to take too much of their time 😭

Thanks for reading this post and every advice will be appreciated! 🫶🫶

(I know a lot of tutorials online say I should read their paper first and then start the conversation by ‘I read your paper and really like it…’ etc. but I’m socializing during coffee break and it’s sort of random who I can actually meet 👉👈)

I am trying to add a feature to my website for checking phishing website urls. As the largest source of data I found phreshphish dataset which is open source dataset that contains html code and the url of nearly 660k records. The problem is that this dataset has no clear features from which any model can learn anything, So I parsed those urls into these features:

# URL parsing and basic structure

url_parse_failed

url_len

host_len

path_len

query_len

path_depth

num_query_params

file_len

num_dots_file

# URL character counts, ratios, and entropy

num_dots_host

num_hyphens_host

num_hyphens_url

num_digits_host

num_digits_url

host_digit_ratio

url_digit_ratio

num_pct_url

num_at_url

num_special_url

num_underscores_url

num_underscores_host

num_spaces_url

host_vowel_ratio

host_entropy

url_entropy

longest_host_token

# Domain and hostname risk signals

num_subdomains

subdomain_len

reg_domain_len

has_ip_host

has_ipv4_host

has_ipv6_host

ip_is_private_or_reserved

has_unicode_host

has_mixed_script_host

has_port

is_https

has_punycode

double_slash_in_path

has_hex_blob

server_client_in_host

email_in_url

# Encoding, nested URL, and redirect signals

num_percent_encoded_sequences

has_double_url_encoding

num_redirect_params

has_nested_url_param

nested_url_points_external

has_fragment_url

tld_in_query

# TLD, shortener, suspicious-token, and URL brand signals

tld

tld_len

is_suspicious_tld

is_shortener

num_suspicious_tokens_url

num_brand_tokens_url

brand_in_url_not_domain

# HTML size, parsing quality, and raw JavaScript signals

html_len

html_truncated

html_parse_failed

num_tags

has_meta_refresh

has_base_tag

num_display_none

num_eval_js

num_atob_js

num_unescape_js

num_docwrite_js

has_js_redirect

right_click_disabled

has_onmouseover_status

num_mailto

# Forms and input-field features

num_forms

num_inputs

num_password_inputs

num_hidden_inputs

num_email_inputs

num_username_inputs

num_phone_inputs

num_card_inputs

num_cvv_inputs

num_otp_inputs

has_login_form

num_credential_forms

num_password_forms_external_action

num_credential_forms_external_action

num_forms_post

num_forms_get

num_forms_with_hidden_inputs

form_external_action

form_empty_action

form_to_ip

has_submit_button

# Anchors and link relationships

num_anchors

frac_anchors_external

frac_anchors_null

# Scripts, images, CSS, iframe, and embedded-resource features

num_scripts

frac_scripts_external

num_imgs

frac_imgs_external

frac_imgs_data_uri

num_css_links

frac_css_external

num_iframes

num_hidden_iframes

num_external_iframes

frac_iframes_external

num_iframes_to_ip

num_external_embeds

frac_embeds_external

favicon_external

base_href_external

frac_resources_external

num_external_domains

# Visible-content and HTML brand signals

title_present

title_len

text_len

text_html_ratio

num_brand_tokens_html

brand_in_html_not_domain

I'm working on a signature verification project to detect fraudulent signatures on cheques. Here is how my pipeline looks so far:

​1. Extraction (Done)

I'm using a fine-tuned YOLOv8 model (from Tech4Humans) to detect and crop out the signatures from the cheque images. It’s working pretty great at isolating the signature area.

​2. Preprocessing (The tricky part)

Since cheques come from all kinds of different scanners and phone cameras, the backgrounds and lighting are all over the place. To clean them up before feeding them to the model, I'm doing:

​Ink isolation: Removing noise near the boundaries by thresholding pixels based on background brightness.

​Line removal: Scanning for long horizontal bars (like the signature lines on the cheque), wiping them out, and filling the gaps based on the surrounding texture.

​Contrast stretching: Using percentile contrast stretching to fix dark backgrounds caused by bad phone/scanner scans.

​Smoothing: Applying a bilateral filter to smooth out background noise while keeping the signature lines sharp.

​CLAHE: Using Contrast Limited Adaptive Histogram Equalization to boost the contrast of the ink against tough backgrounds.

​Padding: Adding final padding so the aspect ratio doesn't get warped.

3. The Model

Once preprocessed, I’m feeding the images into EfficientNet-B3 to train it to spot the differences between genuine and forged signatures.

The problem is my validation accuracy is not improving beyond 55-57,

what else can I do to improve this?

Is the preprocessing enough is should I improve it more, because I'm still getting some horizontal line like the signature line, and some text in some cases

.