标签：#learning

https://www.gnosyslabs.com/case-studies/safety-classifier-sparse-labels Gnosys is an autonomous model engineer: it improves prompts and classifiers when ground truth is too sparse for conventional optimization. On ToxicChat, a public safety benchmark, under realistic label scarcity, it improved a classifier past both the team's starting point and GEPA (a standard prompt optimizer), across two runs of our current method. This note describes what we did, what we found, and where the method underperformed. Results We report harm caught : the share of harmful messages flagged, holding the false positive rate fixed at 5% (one in twenty) for every method, so a difference reflects additional harm caught at the same cost rather than a change of threshold. Both runs below are scored on a held-out set the system never saw. Headline run (3,000) Prior run (1,000) Gnosys 0.777 0.909 Starting classifier 0.731 0.788 GEPA 0.702 0.848 In both runs, Gnosys improved on both the starting classifier and GEPA. In the headline run GEPA not only trailed Gnosys but fell below the starting classifier (0.731 to 0.702); in the prior run it improved on the starting point. This inconsistency is the central difficulty under sparse labels: optimization sometimes helps and sometimes harms, and without trustworthy measurement there is no way to tell which has happened. The comparison is intentionally conservative: both approaches use the same underlying optimizer. The only difference is that Gnosys engineers the objective the optimizer works against. The problem Teams running high-stakes AI classifiers, in content moderation, fraud, claims review, and risk scoring, share one constraint: the ground truth they need is a human judgment that is expensive, slow, and sometimes never arrives. They can verify only a small set of examples while decisions accumulate on everything else. Tuning the model against the few labels on hand is where the difficulty concentrates. Here "few" is literal: about 200 verifi

This is a write-up on our company blog that I wrote, sharing our perspective into Hamiltonian Neural Networks (Greydanus et al., 2019) from a differential-geometry angle rather than the usual "here's the loss function" treatment. I've been working on HNN and LNN adjacent topics for years now and I found this particular lens made the *why* click in a way the standard framing never did for me, and I've been meaning to put everything in writing for a while now. I just feel like the Noether's Theorem which shows conservations can be mapped to symmetries (and in ML context, generalization) is not getting the attention that it deserves around physics informed neural networks. Also, it's a really beautiful architecture and I just love talking about it at every opportunity. It's math-heavy, but I did my best to sprinkle some tension relievers and interactive visuals here and there and make is as easy as it is to follow. Hopefully, I did a good job. I'd genuinely love to see your thoughts and your feedback submitted by /u/FlameOfIgnis [link] [留言]

1. The Problem It Solves Logistic Regression is used when the outcome is a category rather than a number . Most commonly, it's used for binary classification , where the answer is either Yes or No , True or False , or 1 or 0 . Typical business problems include: Will a customer churn? Is this transaction fraudulent? Will a customer click an ad? Will a loan default? Is an email spam? Will a machine fail in the next 24 hours? Unlike Linear Regression, we're not trying to predict a continuous value. Instead, we're predicting the probability that an event belongs to a particular class. For example: A customer may have an 82% probability of churning . The business can then decide whether that probability is high enough to trigger an intervention. 2. Core Intuition Imagine you're trying to predict whether a customer will cancel their subscription. Suppose the only feature you have is how many times they opened your app this month. If you use a straight line like Linear Regression, the predictions quickly become unrealistic. A very active customer might end up with a -20% chance of churn . A completely inactive customer could end up with 140% . Probabilities obviously can't work like that. To fix this, Logistic Regression takes the linear equation and passes it through a mathematical function called the Sigmoid Function . Instead of producing a straight line, it creates an S-shaped curve . No matter how large or small the input becomes, the output always stays between 0 and 1 . That makes it perfect for probability estimation. 3. The Mathematical Model The model first calculates a linear score. Instead of using that score directly, it passes it through the Sigmoid function. Where: z = linear score p̂ = predicted probability The final output is always between 0 and 1 . For example: 0.08 → Very unlikely 0.32 → Low risk 0.65 → Moderate risk 0.94 → Very high probability Businesses can then choose a decision threshold. For example: Probability ≥ 0.50 → Predict Churn Probability

https://pymupdf.io/blog/markdown-in-pymupdf-1-28 PyMuPDF 1.28 release, introduces Markdown as a first class document in PyMuPDF. Seems useful for a variety of workflows. You can create PDFs from Markdown text with control over appearance using CSS submitted by /u/Remote-Spirit526 [link] [留言]

Hi everyone. Do the ACL arr may 2026 reviews come out of July 2nd or do they come out on July 7 th?? How much does one need to get into Main or Findings? I am a bit new to this. Thanks a lot folks. submitted by /u/Anshuman3480 [link] [留言]

The problem no one was solving Every Algerian developer building with AI hits the same wall: an international payment card. OpenAI, Anthropic, Google — every major AI provider assumes you have one. Most Algerian developers don't, or don't want to deal with the friction of currency conversion, card rejections, and unpredictable billing in a foreign currency. That's not a minor inconvenience. It's a barrier that quietly excludes an entire generation of developers from building with the best AI models available — not because they lack the skill, but because of infrastructure that was never designed with them in mind. The vision: AI sovereignty, not just AI access Access alone isn't the goal. The goal is sovereignty — Algeria having its own AI infrastructure layer, controlled locally, billed locally, and built to local compliance standards, instead of depending entirely on foreign gateways with no local accountability. That's what DEVUP AI is: Algeria's first AI inference gateway, built from the ground up to remove every friction point between an Algerian developer and the AI models they need. What DEVUP AI actually does 170+ AI models — including DeepSeek V4, Llama 3.1 405B, Qwen 3, Gemma 2, Mistral, GPT, Claude, and Gemini — through a single API OpenAI-compatible and Anthropic-compatible — point your existing SDK at our endpoint, no code rewrite needed Local DZD billing via Edahabia/CIB — no international card required SATIM-certified payment infrastructure — full compliance with Algeria's national payment standards Scoped JWT authentication for production-grade security A dedicated SDK ( npm install devupai ) and full documentation, so integration takes minutes, not days The technical bar was non-negotiable: this had to be production-grade from day one, not a side project. SATIM certification alone meant building proper transaction validation, receipt generation, chargeback tracking, and rejection-rate monitoring — the same rigor a bank would expect from a payment pr

Here is a question that sounds like a trick: can you build an accurate classifier out of models that are barely better than flipping a coin? Surprisingly, yes. That is the whole idea behind boosting, and AdaBoost is the algorithm that made it famous. I built it from scratch and dropped it into an interactive demo — here's how it actually works, real math, no hand-waving. Play with the live version: https://dev48v.infy.uk/ml/day21-adaboost.html The weak learner: a decision stump AdaBoost's building block is the simplest classifier you can imagine: a decision stump . It is a decision tree with exactly one split. Look at one feature, compare it to one threshold, and call everything on one side "+1" and everything on the other side "−1". That's it. One line, one cut. def stump_predict ( X , dim , thresh , polarity ): pred = np . ones ( len ( X )) if polarity == 1 : pred [ X [:, dim ] <= thresh ] = - 1 else : pred [ X [:, dim ] > thresh ] = - 1 return pred On anything that isn't trivially separable, a single stump is hopeless — on a checkerboard layout it barely passes 55-60%. That is exactly why it's a "weak learner": a model that only beats random guessing by a hair. The magic is in how we combine hundreds of them. Sample weights: a moving spotlight The engine of AdaBoost is a weight on every training point that says "how much does getting this one right matter?" Everything starts equal: n = len ( X ) w = np . full ( n , 1.0 / n ) # uniform: every point weighs 1/n These weights are a probability distribution — they sum to 1. After each round they change: points we got right get lighter, points we missed get heavier. Since we always pick the next stump to minimise weighted error, the heavy points end up dominating the search. The next stump is effectively forced to stare at whatever the committee keeps blowing. Weighted error, not a plain count When we hunt for the best stump each round, we don't count mistakes — we add up the weight of the mistakes: def weighted_error

Please post your questions here instead of creating a new thread. Encourage others who create new posts for questions to post here instead! Thread will stay alive until next one so keep posting after the date in the title. Thanks to everyone for answering questions in the previous thread! submitted by /u/AutoModerator [link] [留言]

Bringing the ideas I've been thinking about for months into life has never been easier, thanks to AI agents. The basic intuition is—give it a prompt, it builds the whole feature, the result looks good. Done. It takes only minutes to build the same thing that would've taken hours otherwise. Yes, I know, everyone's doing that. Right? The reason I'm opening like this is to point out what happened afterwards. I tried to use the search bar, and it fired a request on every keystroke. Wait, what? I didn't do that. Of course I'd add a debounce here. But the agent didn't. Why? I didn't ask it to. I said—build me a search bar, and it built me one that works; but I didn't say exactly what I wanted. Also, I noticed that the search button changes color on hover, but I'd already told it not to do that. The agent forgot, it hallucinated. What's missing then? What was missing was I did not provide the agent with the exact decisions to work with the feature; or did not provide a proper reference point to fallback to, to remediate the hallucination. In other words, I did not provide it with a proper spec. Hence, it took the hidden decisions itself; even though it pulled the feature off. This is the core problem that Spec-Driven Development (SDD) solves. The Hidden Product Decisions Your AI Agent Is Making For You Here's what happens when you describe something to an AI agent and it generates code: lots of decisions get made. Let's take the search bar implementation as an example. Does the filtering happen on the client or the server? Does the URL update so results are shareable? What does an empty query show? Everything, or nothing? I tend to miss nitty-gritty details while reviewing tons of AI generated code in a short amount of time. The code works, the UI looks right, I move on… Every one of those is a decision that belongs to my product. If I don't make the decisions consciously, the agent takes them based on whatever pattern shows up most often in its training data. Take that se

arXiv’s next chapter: Updates on our spin out from Cornell University: https://blog.arxiv.org/2026/06/30/arxivs-next-chapter/ submitted by /u/Nunki08 [link] [留言]

If you’ve spent any time poking around the AIE World’s Fair 2026 website, you may have come across...

I heard about DEV a while back from a former colleague who was posting regularly back then. She won a...

Crossword puzzles are easy. But what if you had to solve one while running inside the hardware constraints of a Large Language Model?

As you’d expect, the opening keynote of the AI Engineer World’s Fair was kicked off by one of its...

For Job Postings please use this template Hiring: [Location], Salary:[], [Remote | Relocation], [Full Time | Contract | Part Time] and [Brief overview, what you're looking for] For Those looking for jobs please use this template Want to be Hired: [Location], Salary Expectation:[], [Remote | Relocation], [Full Time | Contract | Part Time] Resume: [Link to resume] and [Brief overview, what you're looking for] ​ Please remember that this community is geared towards those with experience. submitted by /u/AutoModerator [link] [留言]

A year ago today, I started at Approov. A hundred days in, I wrote about the transition: leaving management, the refreshing day-to-day feedback loop, the strange experience of relearning a craft I thought I'd lost. I stand by most of it. But a hundred days is enough to notice a change; it takes a year to understand it. So here is what a year taught me that a hundred days couldn't. The rust that mattered At a hundred days I called myself rusty. I was. I reached for patterns that no longer fit and looked up syntax I once knew by heart. I expected that to be the hard part. It wasn't. The rust came off faster than I feared, and somewhere along the way I realised I'd been worried about the wrong thing entirely. The agentic era arrived in earnest this year, and it quietly rewrote the job description. The premium skill is no longer how fast you can produce code from memory. It's whether you can write a precise specification and make a strong architectural decision, then judge honestly whether what comes back is any good. Those are not new skills for me. They are the exact skills that years of reviewing architecture and mentoring engineers had been sharpening the whole time. The craft I sat down to relearn was not the craft that turned out to matter. I spent years assuming management had pulled me away from engineering. It hadn't. It had been quietly preparing me for the version of engineering that was coming. Charity Majors has a name for the shape of this: the engineer/manager pendulum. The idea that a healthy career swings between the two, rather than treating management as a one-way door you walk through once and never come back. I didn't choose when mine swung back. But it swung the right way, and the years spent on the other side weren't lost. They were compounding. A secure transaction is a secure transaction The work itself has been a homecoming of a different kind. I spent years in payments. Now I work in mobile and API security. On paper those are different worlds

Originally published on PrepStack . Everyone's first RAG pipeline is the same four boxes: documents, chunk, vector DB, LLM. It demos in an afternoon and then quietly betrays you in production — stale answers, no relationships, no governance, and a model guessing from fragments. The fix is not a bigger vector index. It is to stop storing documents and start storing knowledge . That is Open Knowledge Format (OKF). To be clear up front, because the title is deliberately provocative: OKF does not kill embeddings. Vectors still do the recall. What OKF kills is blind chunking — slicing opaque documents into context-free fragments and hoping cosine similarity reassembles meaning. On Mattrx , a multi-tenant marketing-analytics SaaS (.NET 9 + Azure SQL + a Python FastAPI AI service), replacing blind chunking with OKF + a Context Engine took the assistant's hallucination rate from 18% to 3% and stale-answer rate from 11% to 1.5% . TL;DR Dimension Documents → chunk → vector DB (before) OKF + Context Engine (after) Unit of knowledge Opaque chunk of text Typed, governed knowledge unit Structure None — chunks are islands Metadata + relationships + schemas Freshness Snapshot, rots silently valid_until + live API refs Rules Buried in prose, ignorable First-class data the engine enforces Retrieval Top-k cosine Hybrid + vector + graph Multi-hop questions Unanswerable Answered via relationships Results after the rebuild: Knowledge base restructured into ~11,000 OKF units (Markdown + metadata + relationships + APIs + schemas + business rules). Hallucination 18% -> 3% ; faithfulness 0.96 ; answer-relevance 0.91 . Context tokens/call 14k -> 3.5k — structure lets the engine attach the right thing, not everything. Outdated-answer rate 11% -> 1.5% ( valid_until + metadata freshness). Multi-hop questions unanswerable -> answered via graph retrieval. Deprecated-plan recommendations recurring -> 0 (business rules enforced as data). The one mental shift: a chunk is a fragment of text with no id

My learning so far I absolutely love learning to code. I gave it up to vibe code earlier last year and completely regret it. At first it felt like I was moving faster, but over time I realized I was skipping the part that actually made me better. My learning journey is fueled by passion and the hopes to move into a Go/SWE/Cloud type role. I do not know exactly how I will go about doing so, but I will work until I am noticed. Right now I am trying to focus on building real understanding. Not just getting something to work, but knowing why it works. I want to be able to read errors, debug my own code, understand the tools I am using, and slowly become the kind of developer that can solve problems without panicking. Learn to code! If anyone has any doubts on if coding is "worth it" still, I can account for how personally fulfilling it is. Solving a bug/problem in your own code gives me a personal high. There is something different about struggling with something, walking away, coming back, and finally seeing it click. It reminds you that you are actually learning. Every small fix feels like proof that you are getting better. I am not against using tools or AI. I still think they can be helpful. But I do think there is a big difference between using them to learn and using them to avoid learning. I had to learn that the hard way. So if you are new, or if you stopped for a while like I did, I really think you should keep going. Build small things. Break stuff. Fix it. Read docs even when they are boring. Ask questions. Take notes. Let yourself be bad at it for a while. I do not know where this journey will take me yet, but I know I want to keep showing up.

If you've ever wondered how to visualize, teach, or explore keyboards without owning physical hardware, a keyboard simulator is the answer. In this in-depth guide, we explore what keyboard simulators are, how they work, and why they are changing the way people learn to type. Defining a Keyboard Simulator A keyboard simulator is a software application that digitally recreates the visual, functional, and interactive behavior of a physical keyboard. Unlike a simple on-screen keyboard that merely serves as a typing aid, a true keyboard simulator renders the keyboard in detail — often in three dimensions — and responds to keystrokes in real time, creating an immersive and educational experience. The best keyboard simulators go far beyond static images. They animate individual key presses, replicate the visual design of specific keyboard models, support multiple layouts (QWERTY, Dvorak, AZERTY), and even show animated hands performing the typing — making them extraordinarily useful for remote teaching, accessibility testing, content creation, and learning to type. 💡 Did you know? The Keyboard Simulator by Roboticela is one of the most advanced free and open-source keyboard simulators available today, featuring 3D interactive rendering powered by React Three Fiber, five authentic laptop keyboard models, and eight beautiful visual themes. The Core Components of a Keyboard Simulator A fully-featured keyboard simulator typically includes several key components that work together to create a complete experience: 🎮 3D Rendering Engine: Displays the keyboard model from any angle with smooth rotations and zoom capabilities. ⌨️ Real-Time Key Feedback: Every keystroke on your physical keyboard mirrors instantly on the 3D model. 🖐️ Hand Animation: Animated hands show proper finger placement and movement as you type. 📝 Document Editor: A built-in text editor captures your input and links it to the keyboard visualization. 🎨 Theme System: Multiple visual themes make the experience beau

June 2026 is shaping up to be the month open models stopped playing catch-up. Three major releases in as many weeks have shifted the landscape, and none of them involve the usual frontier-lab drama. NVIDIA Nemotron 3 Ultra: 550B Parameters, Zero Restrictions On June 4, NVIDIA quietly dropped Nemotron 3 Ultra — a 550-billion-parameter behemoth under a fully permissive open license. That's not "open-weight with strings attached" — it's the most capable model you can download, modify, and deploy commercially without asking permission. Early benchmarks show it competitive with GPT-4.5-class models on code generation and reasoning tasks, while significantly outperforming Llama 4 on mathematical reasoning. If you have the hardware (think 8×H100 nodes minimum), this is the new default for self-hosted enterprise AI. GLM-5.2: China's Answer, MIT License Z.AI launched GLM-5.2 on June 13, and it arrived with full MIT-licensed weights within the week. What makes this noteworthy isn't just the permissive license — it's that GLM-5.2 punches well above its weight class on long-context retrieval and multilingual benchmarks. Developers running locally can deploy it on consumer-grade hardware with quantization, making it a strong contender for privacy-sensitive applications. The API tier starts at ~$18/month, but the real value is in the self-hosted path. Gemini 3.5 Flash Gets Computer Use Google DeepMind also shipped computer use capabilities in Gemini 3.5 Flash this month. Think Claude's computer-use agent paradigm, but running on the fastest Flash-tier model Google offers. Early demos show agents completing multi-step browser tasks — form filling, data extraction, web scraping — at significantly lower latency than competing solutions. The throughline is clear: open models are no longer a compromise . Whether you need 550B monsters for reasoning, MIT-licensed alternatives for compliance, or fast agents for automation, June 2026 delivered on all fronts.