😲 Quantifying Surprise – A Data Scientist’s Intro To Information Theory – Part 1/4: Foundations - Related to foundations, a, practical, surprise, scientist’s

ML Feature Management: A Practical Evolution Guide

In the world of machine learning, we obsess over model architectures, training pipelines, and hyper-parameter tuning, yet often overlook a fundamental aspect: how our attributes live and breathe throughout their lifecycle. From in-memory calculations that vanish after each prediction to the challenge of reproducing exact feature values months later, the way we handle attributes can make or break our ML systems’ reliability and scalability.

ML engineers evaluating their feature management approach.

Data scientists experiencing training-serving skew issues.

Technical leads planning to scale their ML operations.

Teams considering Feature Store implementation.

Many ML teams, especially those in their early stages or without dedicated ML engineers, start with what I call “the invisible approach” to feature engineering. It’s deceptively simple: fetch raw data, transform it in-memory, and create capabilities on the fly. The resulting dataset, while functional, is essentially a black box of short-lived calculations — capabilities that exist only for a moment before vanishing after each prediction or training run.

While this approach might seem to get the job done, it’s built on shaky ground. As teams scale their ML operations, models that performed brilliantly in testing suddenly behave unpredictably in production. elements that worked perfectly during training mysteriously produce different values in live inference. When stakeholders ask why a specific prediction was made last month, teams find themselves unable to reconstruct the exact feature values that led to that decision.

These pain points aren’t unique to any single team; they represent fundamental challenges that every growing ML team eventually faces.

Without materialized elements, debugging becomes a detective mission. Imagine trying to understand why a model made a specific prediction months ago, only to find that the elements behind that decision have long since vanished. elements observability also enables continuous monitoring, allowing teams to detect deterioration or concerning trends in their feature distributions over time. Point in time correctness.

When functions used in training don’t match those generated during inference, leading to the notorious training-serving skew. This isn’t just about data accuracy — it’s about ensuring your model encounters the same feature computations in production as it did during training. Reusability.

Repeatedly computing the same attributes across different models becomes increasingly wasteful. When feature calculations involve heavy computational resources, this inefficiency isn’t just an inconvenience — it’s a significant drain on resources.

Approach 1: On-Demand Feature Generation.

The simplest solution starts where many ML teams begin: creating capabilities on demand for immediate use in prediction. Raw data flows through transformations to generate capabilities, which are used for inference, and only then — after predictions are already made — are these capabilities typically saved to parquet files. While this method is straightforward, with teams often choosing parquet files because they’re simple to create from in-memory data, it comes with limitations. The approach partially solves observability since capabilities are saved, but analyzing these capabilities later becomes challenging — querying data across multiple parquet files requires specific tools and careful organization of your saved files.

Illustration of on-demand feature generation inference flow. Image by author.

Approach 2: Feature Table Materialization.

As teams evolve, many transition to what’s commonly discussed online as an alternative to full-fledged feature stores: feature table materialization. This approach leverages existing data warehouse infrastructure to transform and store aspects before they’re needed. Think of it as a central repository where aspects are consistently calculated through established ETL pipelines, then used for both training and inference. This solution elegantly addresses point-in-time correctness and observability — your aspects are always available for inspection and consistently generated. However, it presents its limitations when dealing with feature evolution. As your model ecosystem grows, adding new aspects, modifying existing ones, or managing different versions becomes increasingly complex — especially due to constraints imposed by database schema evolution.

Illustration of feature table materialization inference flow. Image by author.

At the far end of the spectrum lies the feature store — typically part of a comprehensive ML platform. These solutions offer the full package: feature versioning, efficient online/offline serving, and seamless integration with broader ML workflows. They’re the equivalent of a well-oiled machine, solving our core challenges comprehensively. aspects are version-controlled, easily observable, and inherently reusable across models. However, this power comes at a significant cost: technological complexity, resource requirements, and the need for dedicated ML Engineering expertise.

Illustration of feature store inference flow. Image by author.

Contrary to what trending ML blog posts might suggest, not every team needs a feature store. In my experience, feature table materialization often provides the sweet spot — especially when your organization already has robust ETL infrastructure. The key is understanding your specific needs: if you’re managing multiple models that share and frequently modify elements, a feature store might be worth the investment. But for teams with limited model interdependence or those still establishing their ML practices, simpler solutions often provide advanced return on investment. Sure, you could stick with on-demand feature generation — if debugging race conditions at 2 AM is your idea of a good time.

The decision ultimately comes down to your team’s maturity, resource availability, and specific use cases. Feature stores are powerful tools, but like any sophisticated solution, they require significant investment in both human capital and infrastructure. Sometimes, the pragmatic path of feature table materialization, despite its limitations, offers the best balance of capability and complexity.

Remember: success in ML feature management isn’t about choosing the most sophisticated solution, but finding the right fit for your team’s needs and capabilities. The key is to honestly assess your needs, understand your limitations, and choose a path that enables your team to build reliable, observable, and maintainable ML systems.

Many of us might have tried to build a RAG application and noticed it falls significan...

Just last week, Google rolled out Gemini [website] Flash to all Gem...

One of the biggest complaints about ChatGPT is that it provi...

😲 Quantifying Surprise – A Data Scientist’s Intro To Information Theory – Part 1/4: Foundations

During the telecommunication boom, Claude Shannon, in his seminal 1948 paper¹, posed a question that would revolutionise technology:

Shannon’s findings remain fundamental to expressing information quantification, storage, and communication. These insights made major contributions to the creation of technologies ranging from signal processing, data compression ([website], Zip files and compact discs) to the Internet and artificial intelligence. More broadly, his work has significantly impacted diverse fields such as neurobiology, statistical physics and computer science ([website], cybersecurity, cloud computing, and machine learning).

[Shannon’s paper is the] Magna Carta of the Information Age Scientific American.

This is the first article in a series that explores information quantification – an essential tool for data scientists. Its applications range from enhancing statistical analyses to serving as a go-to decision heuristic in cutting-edge machine learning algorithms.

Broadly speaking, quantifying information is assessing uncertainty, which may be phrased as: "how surprising is an outcome?".

This article idea quickly grew into a series since I found this topic both fascinating and diverse. Most researchers, at one stage or another, come across commonly used metrics such as entropy, cross-entropy/KL-divergence and mutual-information. Diving into this topic I found that in order to fully appreciate these one needs to learn a bit about the basics which we cover in this first article.

By reading this series you will gain an intuition and tools to quantify:

Bits/Nats – Unit measures of information.

– Unit measures of information. Self-Information – **** The amount of information in a specific event.

– **** The amount of information in a specific event. Pointwise Mutual Information – The amount of information shared between two specific events.

– The amount of information shared between two specific events. Entropy – The average amount of information of a variable’s outcome.

– The average amount of information of a variable’s outcome. Cross-entropy – The misalignment between two probability distributions (also expressed by its derivative KL-Divergence – a distance measure).

– The misalignment between two probability distributions (also expressed by its derivative – a distance measure). Mutual Information – The co-dependency of two variables by their conditional probability distributions. It expresses the information gain of one variable given another.

No prior knowledge is required – just a basic understanding of probabilities.

I demonstrate using common statistics such as coin and dice 🎲 tosses as well as machine learning applications such as in supervised classification, feature selection, model monitoring and clustering assessment. As for real world applications I’ll discuss a case study of quantifying DNA diversity 🧬. Finally, for fun, I also apply to the popular brain twister commonly known as the Monty Hall problem 🚪🚪 🐐 .

Throughout I provide python code 🐍 , and try to keep formulas as intuitive as possible. If you have access to an integrated development environment (IDE) 🖥 you might want to plug 🔌 and play 🕹 around with the numbers to gain a more effective intuition.

This series is divided into four articles, each exploring a key aspect of Information Theory:

😲 Quantifying Surprise: 👈 👈 👈 YOU ARE HERE In this opening article, you’ll learn how to quantify the "surprise" of an event using _self-informatio_n and understand its units of measurement, such as _bit_s and _nat_s. Mastering self-information is essential for building intuition about the subsequent concepts, as all later heuristics are derived from it. 🤷 Quantifying Uncertainty: Building on self-information, this article shifts focus to the uncertainty – or "average surprise" – associated with a variable, known as entropy. We’ll dive into entropy’s wide-ranging applications, from Machine Learning and data analysis to solving fun puzzles, showcasing its adaptability. 📏 Quantifying Misalignment: Here, we’ll explore how to measure the distance between two probability distributions using entropy-based metrics like cross-entropy and KL-divergence. These measures are particularly valuable for tasks like comparing predicted versus true distributions, as in classification loss functions and other alignment-critical scenarios. 💸 Quantifying Gain: Expanding from single-variable measures, this article investigates the relationships between two. You’ll discover how to quantify the information gained about one variable ([website], target Y) by knowing another ([website], predictor X). Applications include assessing variable associations, feature selection, and evaluating clustering performance.

Each article is crafted to stand alone while offering cross-references for deeper exploration. Together, they provide a practical, data-driven introduction to information theory, tailored for data scientists, analysts and machine learning practitioners.

Disclaimer: Unless otherwise mentioned the formulas analysed are for categorical variables with c≥2 classes (2 meaning binary). Continuous variables will be addressed in a separate article.

🚧 Articles (3) and (4) are currently under construction. I will share links once available. Follow me to be notified 🚧.

Quantifying Surprise with Self-Information.

Self-information is considered the building block of information quantification.

It is a way of quantifying the amount of "surprise" of a specific outcome.

Formally self-information, or also referred to as Shannon Information or information content, quantifies the surprise of an event x occurring based on its probability, p(x). Here we denote it as hₓ:

Self-information _h_ₓ is the information of event x that occurs with probability p(x).

The units of measure are called bits. One bit (binary digit) is the amount of information for an event x that has probability of p(x)=½. Let’s plug in to verify: hₓ=-log₂(½)= log₂(2)=1 bit.

This heuristic serves as an alternative to probabilities, odds and log-odds, with certain mathematical properties which are advantageous for information theory. We discuss these below when learning about Shannon’s axioms behind this choice.

It’s always informative to explore how an equation behaves with a graph:

Bernoulli trial self-information h(p). Key elements: Monotonic, h(p=1)=0, h(p →)→∞.

To deepen our understanding of self-information, we’ll use this graph to explore the stated axioms that justify its logarithmic formulation. Along the way, we’ll also build intuition about key elements of this heuristic.

To emphasise the logarithmic nature of self-information, I’ve highlighted three points of interest on the graph:

At p=1 an event is guaranteed, yielding no surprise and hence zero bits of information (zero bits). A useful analogy is a trick coin (where both sides show HEAD).

Reducing the probability by a factor of two (p=½​) increases the information to _hₓ=_1 bit. This, of course, is the case of a fair coin.

Further reducing it by a factor of four results in hₓ(p=⅛)=3 bits.

If you are interested in coding the graph here is a python script:

Self-Information hₓ=-log₂(p(x)) quantifies the amount of "surprise" of a specific outcome x.

Referencing prior work by Ralph Hartley, Shannon chose -log₂(p) as a manner to meet three axioms. We’ll use the equation and graph to examine how these are manifested:

An event with probability 100% is not surprising and hence does not yield any information. In the trick coin case this is evident by p(x)=1 yielding hₓ=0. Less probable events are more surprising and provide more information. This is apparent by self-information decreasing monotonically with increasing probability. The property of Additivity – the total self-information of two independent events equals the sum of individual contributions. This will be explored further in the upcoming fourth article on Mutual Information.

There are mathematical proofs (which are beyond the scope of this series) that show that only the log function adheres to all three².

The application of these axioms reveals several intriguing and practical properties of self-information:

Minimum bound : The first axiom hₓ(p=1)=0 establishes that self-information is non-negative, with zero as its lower bound. This is highly practical for many applications.

: The first axiom hₓ(p=1)=0 establishes that self-information is non-negative, with zero as its lower bound. This is highly practical for many applications. Monotonically decreasing : The second axiom ensures that self-information decreases monotonically with increasing probability.

: The second axiom ensures that self-information decreases monotonically with increasing probability. No Maximum bound: At the extreme where _p→_0, monotonicity leads to self-information growing without bound hₓ(_p→0) →_ ∞, a feature that requires careful consideration in some contexts. However, when averaging self-information – as we will later see in the calculation of entropy – probabilities act as weights, effectively limiting the contribution of highly improbable events to the overall average. This relationship will become clearer when we explore entropy in detail.

It is useful to understand the close relationship to log-odds. To do so we define p(x) as the probability of event x to happen and p(¬x)=1-p(x) of it not to happen. log-odds(x) = log₂(p(x)/p(¬x))= h(¬x) – h(x).

The main takeaways from this section are.

Axiom 1: An event with probability 100% is not surprising Axiom 2: Less probable events are more surprising and, when they occur, provide more information. Self information (1) monotonically decreases (2) with a minimum bound of zero and (3) no upper bound.

In the next two sections we further discuss units of measure and choice of normalisation.

A bit, as mentioned, represents the amount of information associated with an event that has a 50% probability of occurring.

The term is also sometimes referred to as a Shannon, a naming convention proposed by mathematician and physicist David MacKay to avoid confusion with the term ‘bit’ in the context of digital processing and storage.

After some deliberation, I decided to use ‘bit’ throughout this series for several reasons:

This series focuses on quantifying information, not on digital processing or storage, so ambiguity is minimal.

Shannon himself, encouraged by mathematician and statistician John Tukey, used the term ‘bit’ in his landmark paper.

‘Bit’ is the standard term in much of the literature on information theory.

Throughout this series we use base 2 for logarithms, reflecting the intuitive notion of a 50% chance of an event as a fundamental unit of information.

An alternative commonly used in machine learning is the natural logarithm, which introduces a different unit of measure called nats (short for natural units of information). One nat corresponds to the information gained from an event occurring with a probability of 1/e where e is Euler’s number (≈[website] In other words, 1 nat = -ln(p=(1/e)).

The relationship between bits (base 2) and nats (natural log) is as follows:

Think of it as similar to a monetary current exchange or converting centimeters to inches.

In his seminal publication Shanon explained that the optimal choice of base depends on the specific system being analysed (paraphrased slightly from his original work):

"A device with two stable positions […] can store one bit of information" (bit as in binary digit ).

). "A digit wheel on a desk computing machine that has ten stable positions […] has a storage capacity of one decimal digit ."³.

."³ "In analytical work where integration and differentiation are involved the base e is sometimes useful. The resulting units of information will be called natural units."

Key aspects of machine learning, such as popular loss functions, often rely on integrals and derivatives. The natural logarithm is a practical choice in these contexts because it can be derived and integrated without introducing additional constants. This likely explains why the machine learning community frequently uses nats as the unit of information – it simplifies the mathematics by avoiding the need to account for factors like ln(2).

As shown earlier, I personally find base 2 more intuitive for interpretation. In cases where normalisation to another base is more convenient, I will make an effort to explain the reasoning behind the choice.

To summarise this section of units of measure:

bit = amount of information to distinguish between two equally likely outcomes.

Now that we are familiar with self-information and its unit of measure let’s examine a few use cases.

Quantifying Event Information with Coins and Dice.

In this section, we’ll explore examples to help internalise the self-information axioms and key functions demonstrated in the graph. Gaining a solid understanding of self-information is essential for grasping its derivatives, such as entropy, cross-entropy (or KL divergence), and mutual information – all of which are averages over self-information.

The examples are designed to be simple, approachable, and lighthearted, accompanied by practical Python code to help you experiment and build intuition.

Note: If you feel comfortable with self-information, feel free to skip these examples and go straight to the Quantifying Uncertainty article.

To further explore the self-information and bits, I find analogies like coin flips and dice rolls particularly effective, as they are often useful analogies for real-world phenomena. Formally, these can be described as multinomial trials with n=1 trial. Specifically:

A coin flip is a Bernoulli trial, where there are c=2 possible outcomes ([website], heads or tails).

Rolling a die represents a categorical trial, where c≥3 outcomes are possible ([website], rolling a six-sided or eight-sided die).

As a use case we’ll use simplistic weather reports limited to featuring sun 🌞 , rain 🌧 , and snow ⛄️.

Now, let’s flip some virtual coins 👍 and roll some funky-looking dice 🎲 ….

We’ll start with the simplest case of a fair coin ([website], 50% chance for success/Heads or failure/Tails).

Imagine an area for which at any given day there is a 50:50 chance for sun or rain. We can write the probability of each event be: p(🌞 )=p(🌧 )=½.

As seen above, according the the self-information formulation, when 🌞 or 🌧 is reported we are provided with h(🌞 __ )=h(🌧 )=-log₂(½)=1 bit of information.

We will continue to build on this analogy later on, but for now let’s turn to a variable that has more than two outcomes (c≥3).

Before we address the standard six sided die, to simplify the maths and intuition, let’s assume an 8 sided one (_c=_8) as in Dungeons Dragons and other tabletop games. In this case each event ([website], landing on each side) has a probability of p(🔲 ) = ⅛.

When a die lands on one side facing up, [website], value 7️⃣, we are provided with h(🔲 =7️⃣)=-log₂(⅛)=3 bits of information.

For a standard six sided fair die: p(🔲 ) = ⅙ → an event yields __ h(🔲 )=-log₂(⅙)[website] bits.

Comparing the amount of information from the fair coin (1 bit), 6 sided die ([website] bits) and 8 sided (3 bits) we identify the second axiom: The less probable an event is, the more surprising it is and the more information it yields.

Self information becomes even more interesting when probabilities are skewed to prefer certain events.

Let’s assume a region where p(🌞 ) = ¾ and p(🌧 )= ¼.

When rain is reported the amount of information conveyed is not 1 bit but rather h(🌧 )=-log₂(¼)=2 bits.

When sun is reported less information is conveyed: h(🌞 )=-log₂(¾)[website] bits.

As per the second axiom— a rarer event, like p(🌧 )=¼, reveals more information than a more likely one, like p(🌞 )=¾ – and vice versa.

To further drive this point let’s now assume a desert region where p(🌞 ) =99% and p(🌧 )= 1%.

If sunshine is reported – that is kind of expected – so nothing much is learnt ("nothing new under the sun" 🥁) and this is quantified as h(🌞 )[website] bits. If rain is reported, however, you can imagine being quite surprised. This is quantified as h(🌧 )[website] bits.

In the following python scripts you can examine all the above examples, and I encourage you to play with your own to get a feeling.

First let’s define the calculation and printout function:

import numpy as np def print_events_self_information(probs): for ps in probs: print(f"Given distribution {ps}") for event in ps: if ps[event] != 0: self_information = [website][event]) #same as: [website][event])/[website] text_ = f'When `{event}` occurs {[website]} bits of information is communicated' print(text_) else: print(f'a `{event}` event cannot happen p=0 ') print("=" * 20).

Next we’ll set a few example distributions of weather frequencies.

# Setting multiple probability distributions (each sums to 100%) # Fun fact - 🐍 💚 Emojis! probs = [{'🌞 ': [website], '🌧 ': [website]}, # half-half {'🌞 ': [website], '🌧 ': [website]}, # more sun than rain {'🌞 ': [website], '🌧 ': [website]} , # mostly sunshine ] print_events_self_information(probs).

Given distribution {'🌞 ': [website], '🌧 ': [website]} When `🌞 ` occurs [website] bits of information is communicated When `🌧 ` occurs [website] bits of information is communicated ==================== Given distribution {'🌞 ': [website], '🌧 ': [website]} When `🌞 ` occurs [website] bits of information is communicated When `🌧 ` occurs [website] bits of information is communicated ==================== Given distribution {'🌞 ': [website], '🌧 ': [website]} When `🌞 ` occurs [website] bits of information is communicated When `🌧 ` occurs [website] bits of information is communicated.

Let’s examine a case of a loaded three sided die. [website], information of a weather in an area that reports sun, rain and snow at uneven probabilities: p(🌞 ) = [website], p(🌧 )[website], p(⛄️)[website].

print_events_self_information([{'🌞 ': [website], '🌧 ': [website], '⛄️': [website]}]).

Given distribution {'🌞 ': [website], '🌧 ': [website], '⛄️': [website]} When `🌞 ` occurs [website] bits of information is communicated When `🌧 ` occurs [website] bits of information is communicated When `⛄️` occurs [website] bits of information is communicated.

What we saw for the binary case applies to higher dimensions.

To summarise – we clearly see the implications of the second axiom:

When a highly expected event occurs – we do not learn much, the bit count is low .

event occurs – we do not learn much, the bit count is . When an unexpected event occurs – we learn a lot, the bit count is high.

In this article we embarked on a journey into the foundational concepts of information theory, defining how to measure the surprise of an event. Notions introduced serve as the bedrock of many tools in information theory, from assessing data distributions to unraveling the inner workings of machine learning algorithms.

Through simple yet insightful examples like coin flips and dice rolls, we explored how self-information quantifies the unpredictability of specific outcomes. Expressed in bits, this measure encapsulates Shannon’s second axiom: rarer events convey more information.

While we’ve focused on the information content of specific events, this naturally leads to a broader question: what is the average amount of information associated with all possible outcomes of a variable?

In the next article, Quantifying Uncertainty, we build on the foundation of self-information and bits to explore entropy – the measure of average uncertainty. Far from being just a beautiful theoretical construct, it has practical applications in data analysis and machine learning, powering tasks like decision tree optimisation, estimating diversity and more.

💌 Follow me here, join me on LinkedIn or 🍕 buy me a pizza slice!

Even though I have twenty years of experience in data analysis and predictive modelling I always felt quite uneasy about using concepts in information theory without truly understanding them.

The purpose of this series was to put me more at ease with concepts of information theory and hopefully provide for others the explanations I needed.

Check out my other articles which I wrote to superior understand Causality and Bayesian Statistics:

¹ A Mathematical Theory of Communication, Claude E. Shannon, Bell System Technical Journal 1948.

It was later renamed to a book The Mathematical Theory of Communication in 1949.

[Shannon’s "A Mathematical Theory of Communication"] the blueprint for the digital era – Historian James Gleick.

² See Wikipedia page on Information Content ([website], self-information) for a detailed derivation that only the log function meets all three axioms.

³ The decimal-digit was later renamed to a hartley (symbol Hart), a ban or a dit. See Hartley (unit) Wikipedia page.

Unless otherwise noted, all images were created by the author.

Many thanks to Will Reynolds and Pascal Bugnion for their useful comments.

organization Realising scientists are the real superheroes Share.

Meet Edgar Duéñez-Guzmán, a research engineer on our Multi-Agent Resea...

Research Scaling up learning across many different robot types Share.

Together with partners from 33 academic labs, we have pooled ...

Research Millions of new materials discovered with deep learning Share.

AI tool GNoME finds [website] million new crystals, including 380...

Perplexity lets you try DeepSeek R1 - without the security risk

Chinese startup DeepSeek AI and its open-source language models took over the news cycle this week. Besides being comparable to models like Anthropic's Claude and OpenAI's o1, the models have raised several concerns about data privacy, security, and Chinese-government-enforced censorship within their training.

AI search platform Perplexity and AI assistant [website] have found a way around that.

Also: Deepseek's AI model proves easy to jailbreak - and worse.

On Monday, Perplexity . The free plan gives clients three Pro-level queries per day, which you could use with R1, but you'll need the $20 per month Pro plan to access it more than that.

In another post, the corporation confirmed that it hosts DeepSeek "in US/EU data centers - your data never leaves Western servers," assuring people that their data would be safe if using the open-source models on Perplexity.

"None of your data goes to China," Perplexity CEO Aravind Srinivas reiterated in a LinkedIn post.

Also: I tested DeepSeek's R1 and V3 coding skills - and we're not all doomed (yet).

DeepSeek's AI assistant, powered by both its V3 and R1 models, is accessible via browser or app -- but those require communication with the corporation's China-based servers, which creates a security risk. consumers who download R1 and run it locally on their devices will avoid that issue, but still run into censorship of certain topics determined by the Chinese government, as it's built in by default.

As part of offering R1, Perplexity claimed it removed at least some of the censorship built into the model. Srinivas posted a screenshot on X of query results that acknowledge the president of Taiwan.

To check, I asked R1 about Tiananmen Square using Perplexity, but it refused to answer.

Perplexity support clarified that this was because R1 was set to writing mode, and therefore not connected to reports that would help it provide an uncensored answer. However, when I then asked R1 if it is trained not to answer certain questions determined by the Chinese government, it responded that it's designed to "focus on factual information" and "avoid political commentary," and that its training "emphasizes neutrality in global affairs" and "cultural sensitivity."

Also: OpenAI's new Deep Research agent can do in 5 minutes what might take you hours.

[website] offers both V3 and R1, similarly only through its Pro tier, which is $15 per month (discounted from the usual $20) and without any free queries. In addition to access to all the models [website] offers, the Pro plan comes with file uploads of up to 25MB per query, a 64k maximum context window, and access to research and custom agents.

Bryan McCann, [website] cofounder and CTO, explained in an email to ZDNET that people can access R1 and V3 via the platform in three ways, all of which use "an unmodified, open source version of the DeepSeek models hosted entirely within the United States to ensure user privacy."

"The first, default way is to use these models within the context of our proprietary trust layer. This gives the models access to public web findings, a bias towards citing those findings, and an inclination to respect those findings while generating responses," McCann continued. "The second way is for consumers to turn off access to public web findings within their source controls or by using the models as part of Custom Agents. This option allows consumers to explore the models' unique capabilities and behavior when not grounded in the public web. The third way is for consumers to test the limits of these models as part of a Custom Agent by adding their own instructions, files, and findings."

Also: The best open-source AI models: All your free-to-use options explained.

McCann noted that [website] compared DeepSeek models' responses based on whether it had access to web findings. "We noticed that the models' responses differed on several political topics, sometimes refusing to answer on certain issues when public web findings were not included," he explains. "When our trust layer was enabled, encouraging citation of public web findings, the models' responses respected those findings, seemingly overriding prior political biases."

For developers, DeepSeek R1 is now available on platforms including Azure and Github, AWS, and Nvidia,.

Since DeepSeek challenged OpenAI two weeks ago, the open- vs. closed-source AI...

Can you jailbreak Anthropic's latest AI safety measure? Researchers want you t...

The most notable part of Google's latest responsible AI investigation could be what i...