frontpage.
newsnewestaskshowjobs

Open Source @Github

fp.

Java4Shell: RCE in OpenJDK when processing Base64

https://calif.io/java4shell/
685•werrett•8h ago•185 comments

ID.me terms required for IRS sign-in

https://consumerrights.wiki/w/ID.me_terms_required_for_IRS_sign-in
233•DeepLogin•4h ago•101 comments

Google's AI answers reducing search traffic by 40%

https://revscope.co/blog/search-seo-geo-2026/
228•slashdev•5h ago•155 comments

GPT‑6.2 Astra and Sol

https://openai.com/index/introducing-gpt-6-2-astra-sol/
1176•jasondavies•11h ago•741 comments

Quad9's withdrawal from France: A canary in the coal mine

https://blog.cloudflare.com/quad9-withdrawal-from-france/
392•subset•7h ago•128 comments

Microsoft's ONNX Runtime has disappeared from GitHub

https://github.com/microsoft/onnxruntime
213•nvader•6h ago•51 comments

Nvidia stopped disclosing Singapore sales as revenues hit $104B

https://www.ft.com/content/dbde7a30-548c-4f9d-a4be-7898a0c24dcf
460•louiereederson•12h ago•217 comments

Archive Team is archiving the Apple Support Community (closes November 20, 2026)

https://wiki.archiveteam.org/index.php/Apple_Discussions
140•digitaldragon•5h ago•50 comments

Highly classified US national security communications network goes down

https://www.cnn.com/2026/11/17/politics/highly-classified-national-security-communications-networ...
528•monkeydust•13h ago•601 comments

GoGoGrandparent (YC S16) Is a Front End JavaScript / TypeScript Engineer

https://www.ycombinator.com/companies/gogograndparent/jobs/05woouL-front-end-javascript-typescrip...
1•davidchl•1h ago

jQuery 4.1.0

https://github.com/jquery/jquery/releases/tag/4.1.0
282•petecooper•9h ago•153 comments

MAI Code 2 and Code 2 Flash

https://microsoft.ai/news/introducing-mai-code-2-and-mai-code-2-flash/
316•lemonish97•10h ago•144 comments

350 years ago, Ole Rømer discovered that light has a finite speed

https://www.sciencenorway.no/culture-history-history-of-science/350-years-ago-this-man-discovered...
290•dxs•9h ago•84 comments

Phrack 73 Released

https://phrack.org/issues/73/introduction_md
329•notmine1337•10h ago•49 comments

Why is Gemini 4 Carbon taking so long?

https://kernel.dev/blog/why-is-gemini-4-carbon-taking-so-long/
13•deenadz•1h ago•2 comments

Harvard researchers find AI coding agents shifted the bottleneck to code review

https://complexdiscovery.com/harvard-researchers-find-ai-coding-agents-shifted-the-bottleneck-to-...
115•judahmeek•8h ago•167 comments

Fun with Constrained Programming

https://blog.cmpxchg8b.com/2012/09/fun-with-constrained-programming.html
43•colejohnson66•3d ago•0 comments

H-1B Executive Actions in 2026 [pdf]

https://www.everycrsreport.com/files/2026-10-14_IN12747_fcb1389788aa7b9102b795882af042e85d20532c.pdf
12•rawgabbit•1h ago•7 comments

Cerebras Disaggregated Inference

https://www.cerebras.ai/blog/cerebras-launches-disaggregated-inference
52•emschwartz•4h ago•13 comments

Solid 2.0

https://www.solidjs.com/blog/solid-2-0-the-long-hold/
263•pier25•10h ago•75 comments

What is the best harness for each model?

https://runta.com/blog/introducing-frontierharness-eval-v1-1/
352•Edward40•14h ago•123 comments

Duality of Quadrilaterals via Quaternions [pdf]

https://scholarworks.uni.edu/cgi/viewcontent.cgi?article=1193&context=surp
8•teleforce•3d ago•0 comments

Tencent Hy4 Flash

https://hy.tencent.ai/research/hy4-flash
87•lyra1337•8h ago•12 comments

Launch HN: StarSling (YC P25) – Self-improving CI for agent-volume repos

https://starsling.dev
64•yonasb•10h ago•36 comments

Apple Services Down

https://developer.apple.com/system-status/
667•willy_k•11h ago•373 comments

Web Browser Engineering (2021)

https://browser.engineering/
145•ibobev•9h ago•20 comments

Latent Lattice Language Models

https://shivamduggal4.github.io/latent-lattice-language-models/
41•E-Reverance•7h ago•5 comments

Not Everything Needs an LLM

https://newsletter.posthog.com/p/decision-models
126•speckx•11h ago•52 comments

Effects of a Nuclear Detonation in Low Earth Orbit

https://arxiv.org/abs/2611.09827
92•PaulHoule•9h ago•66 comments

Who Builds the Machines That Build the Machines?

https://read.corematter.com/p/section-232-us-machine-tools
119•gmays•11h ago•36 comments
Open in hackernews

The Speed of VITs and CNNs

https://lucasb.eyer.be/articles/vit_cnn_speed.html
74•jxmorris12•1y ago

Comments

GaggiX•1y ago
>text in photos, phone screens, diagrams and charts, 448px² is enough

Not in the graph you provided as an example.

yorwba•1y ago
It has this note at the bottom:

"Note that I chose an unusually long chart to exemplify an extreme case of aspect ratio stretching. Still, 512px² is enough.

This is two_col_40643 from ChartQA validation set. Original resolution: 800x1556."

But yeah, ultimately which resolution you need depends on the image content, and if you need to squeeze out every bit of accuracy, processing at the original resolution is unavoidable.

zamadatix•1y ago
It's enough, especially if you select one of the sharper options like Lanczos, but 512px is sure a lot easier for a human.
ninamoss•1y ago
Really appreciated the post, very insightful. We also use VITs for some of our models and find that between model compilation and hyperparameter tuning we are able to get sub second evaluation of images on commodity hardware while maintaining a high precision and recall.
John7878781•1y ago
In the Twitter thread the article mentions, LeCun makes his claim only for "high-resolution" images and the article assumes 1024x1024 to fall under this category. To me, 1024x1024 is not "high-resolution." This assumption is flawed imo

I currently use convnext for image classification at a size of 4096x2048 (definitely counts as "high-resolution"). For my use case, it would never be practical to use VITs for this. I can't downscale the resolution because extremely fine details need to be preserved.

I don't think LeCun's comment was a "knee-jerk reaction" as the article claims.

hedgehog•1y ago
LeCun's technical assessments have borne out over a lot of years. The likely next step in scaling vision transformers is to treat the image as a MIP pyramid and use the transformer to adaptively sample out of that. Requires RL to train (tricky) but it would decouple compute footprint from input size.
tbalsam•1y ago
As someone who has worked in computer vision ML for nearly a decade, this sounds like a terrible idea.

You don't need RL remotely for this usecase. Image resolution pyramids are pretty normal tho and handling them well/efficiently is the big thing. Using RL for this would be like trying to use graphene to make a computer screen because it's new and flashy and everyone's talking about it. RL is inherently very sample inefficient, and is there to approximate when you don't have certain defined informative components, which we do have in computer vision in spades. Crossentropy losses (and the like) are (generally, IME/IMO) what RL losses try to approximate, only on a much larger (and more poorly-defined) scale.

Please mark speculation as such -- I've seen people see confident statements like this and spend a lot of time/manhours on it (because it seems plausible). It is not a bad idea from a creativity standpoint, but practically is most certainly not the way to go about it.

(That being said, you can try for dynamic sparsity stuff, it has some painful tradeoffs that generally don't scale but no way in Illinois do you need RL for that)

kookamamie•1y ago
> You don't need very high resolution

Yes, you do. Also, 1024x1024 is not high resolution.

An example is segmenting basic 1920x1080 (FHD) video in 60 Hz formats.

CHY872•1y ago
The article basically argues: You would expect to get similarly good results with subsampling in practice. E.g. no need to process at 1920x1080 when you can do 960x540. Separately, you can break down many problems into smaller tiles and get similar quality results without the compute overheads of a high res ViT.
dimatura•1y ago
Yeah, the article was painting with a bit too of a broad stroke IMO, though they did briefly acknowledge "special exceptions" such as satellite or medical imagery. It's very application-dependent.

That said, in my experience beginners do often overestimate how much image resolution is needed for a given task for some reason. I often find myself asking to retry their experiments with a lower resolution. There's a surprising amount of information in 128x128 or even smaller images.

magicalhippo•1y ago
I have a vivid memory of playing Rise of the Triad[1] against my buddy over serial cable. As most PC games from back then, it used mode 13h[2], so 320x200 resolution with a 256 color palette.

I have the distinct memory of firing a rocket at him from far away because I thought that one pixel had the wrong color, and killing him to his great frustration. Good times.

You can play the shareware portion of the game here[3] to get an idea.

[1]: https://en.wikipedia.org/wiki/Rise_of_the_Triad

[2]: https://en.wikipedia.org/wiki/Mode_13h

[3]: https://www.dosgames.com/game/rise-of-the-triad/

jacobgorm•1y ago
A nice feature of CNNs is that you can change the resolution at inference time without retraining. For instance, when the user plugs in a camera with a different aspect or decides to the change the orientation of his phone from landscape to portrait. It is not clear to me if VITs can support aspect or resolution changes without any retraining?
lava_pidgeon•1y ago
Can you elaborate? In my experience it is the opposite: CNNs are highly depend on the input tensor shapes thus resolution change need even an architectional change. While resolution changes in ViT lead to more tokens, a ViT model can handle that (for image classification e.g. you always take the CLS token, Segmentation maps and similar task have the same output as in the input).
hedgehog•1y ago
SPECULATION ALERT! I think there's reasonable motivation though. In the last few years there has been a steady drip of papers in the general area, at least insofar as they use vision transformers and image pyramids, and work on applying RL to object detection goes back before that. IoU and the general way SSD and YOLO descendants are set up is kind of wacky so I don't think it's much of a stretch to try to both 1) avoid attending to or materializing most of the pyramid, and 2) go directly to feature proposals without worrying about box anchors or grid cells or any of that. Now with that context if you still think it's a terrible idea, well, you're probably more current than I am.
tbalsam•1y ago
Not bad frustrations at all. That said -- IoU is how the final box scores are calculated, that doesn't change how you do feature aggregation, this will happen in basically any technique you use.

Modern SSD/YOLO-style detectors use efficient feature pyramids, you need that to know where to propose where things are in the image.

This sounds a lot like going back to the old school object detection techniques which end up being more inefficient in general, generally very compute inefficient.

dimatura•1y ago
There's been a huge amount of work on image transformers since the original VIT. A lot of it has explored different schemes to slice up the image in tokens, and I've definitely seen some of it using a multiresolution pyramid. Not sure about the RL part - after all, the higher/low-res levels of the pyramid would add less tokens than the base/high-res level, so it doesn't seem that necessary. But given the sheer volume of work out there I can bet someone has explored this idea or something pretty close to it already.
djoldman•1y ago
Interesting. Can you run your images through a segment model first and then only classify interesting boxes?
lairv•1y ago
Curious what kind of classification problems requires full 4096x2048 images, couldn't you feed multiple 512x512 overlapping crops instead?
threeducks•1y ago
ConvNeXT's architecture contains an AdaptiveAvgPool2d layer: https://github.com/pytorch/vision/blob/5f03dc524bdb7529bb4f2...

This means that you can split your image into tiles, process each tile individually, average the results, apply a final classification layer to the average and get exactly the same result. For reference, see the demonstration below.

You could of course do exactly the same thing with a vision transformer instead of a convolutional neural network.

That being said, architecture is wildly overemphasized in my opinion. Data is everything.

    import torch, torchvision.models

    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model = torchvision.models.convnext_small()
    model.to(device)
    tile_size, image_size = 32, 224 # note that 32 divides 224 evenly
    image = torch.randn((1, 3, image_size, image_size), device=device)

    # Process image as usual
    x_expected = model(image)

    # Process image as tiles (using for-loops for educational purposes; should use .view and .permute instead for performance)
    features = [
        model.features(image[:, :, y:y + tile_size, x:x + tile_size])
        for y in range(0, image_size, tile_size)
        for x in range(0, image_size, tile_size)]
    x = model.classifier(sum(features) / len(features))

    print(f"Mean squared error: {(x - x_expected).pow(2).mean().item():.20f}")
tbalsam•1y ago
As someone who's done a fair bit of architecture work -- both are important! Making it either or is a very silly thing, both are the limiting factor for the other and there are no two ways about it.

Also, for classification, MaxPooling is often far superior, you can learn an average smoothing filter in your convolutions beforehand in a data-dependent manner so that Nyquist sampling stuff is properly preserved.

Also, please do smoothed crossentropy for image class stuff (generally speaking, unless maybe data is hilariously large), MSE won't nearly cut it!

But that being said, adaptive stuff certainly is great when doing classification. Something to note is that batching does become an issue at a certain point -- as well as certain other fine-grained details if you're simply going to average it all down to one single vector (IIUC).

threeducks•1y ago
> Also, please do smoothed crossentropy for image class stuff (generally speaking, unless maybe data is hilariously large), MSE won't nearly cut it!

Of course. The MSE here is not intended to be a training loss, but as a means to demonstrate that both approaches lead to almost the same result except for some rounding error. The MSE is somewhere in the order of 10^-9.

> Also, for classification, MaxPooling is often far superior, you can learn an average smoothing filter in your convolutions beforehand in a data-dependent manner so that Nyquist sampling stuff is properly preserved.

I don't think that max pooling the last feature maps would be a good idea here, because it would cut off about 98 % of the gradients and training would take much longer. (The shape of the input feature layer is (1, 768, 7, 7), pooled to (1, 768, 1, 1).)

> Something to note is that batching does become an issue at a certain point

Could you elaborate on that?

tbalsam•1y ago
> The MSE here is not intended to be a training loss, but as a means to demonstrate that both approaches lead to almost the same result except for some rounding error.

Ah, gotcha

> I don't think that max pooling the last feature maps would be a good idea here, because it would cut off about 98 % of the gradients and training would take much longer. (The shape of the input feature layer is (1, 768, 7, 7), pooled to (1, 768, 1, 1).)

MaxPooling is generally only useful if you're training your network for it, but in most cases it ends up performing better. That sparsity actually ends up being a good thing -- you generally need to suppress all of those unused activations! It ends up being quite a wide gap in practice (and, if you have convolutions beforehand -- using avgpooling2d is a bit of extra wasted extra computation blurring the input)

> Could you elaborate on that?

Variable-sized inputs don't batch easily as the input dims need to match, you can go down the padding route but that has its own particularly hellacious costs with it that end up taking away from compute that you could be using for other useful things.

dimatura•1y ago
Slicing up images to analyze them is definitely something people do - in many cases, such as satellite imagery, there is not much alternative. But it should be done mindfully, especially if there are differences between the training and testing steps. Depending on the architecture and the application, it's not the same as processing the whole image at once. Some differences are more or less obvious (for example, you might have border artifacts), but others are more subtle. For example, contrary to the expected positional equivariance of convolutional nets, they can implicitly encode positional information based on where they see border padding during training. For some types of normalization such as instance normalization, the statistics of the normalization may vary significantly when applied across patches or whole images.