I spent the last few weeks on two related projects. The first was reproducing a 2024 Scientific Reports paper by Lee et al., “Social signals predict contemporary art prices better than visual features, particularly in emerging markets”. It trains an XGBoost model on 34,200 auction records from 590 living artists. The second was building an art platform with a knowledge graph of artists, owners, and auction records. It’s basically the data plumbing you’d need around a model like that one if you wanted to do anything useful with it.

Both projects kept circling back to the same question: can you actually predict what an artwork sells for? The answer is yes, but not from looking at the artwork. The features that matter are almost entirely social.

Why Art Is Hard to Value

#

Before writing any code, I spent a couple of days reading about how appraisers and auction houses price work. The list of factors is long and most of them don’t quantify cleanly. Provenance — who’s owned it, where it’s been shown, which catalogues reference it. Attribution: a piece confirmed by the artist’s foundation is worth orders of magnitude more than one that’s only “attributed to” them. The artist’s reputation, built from solo shows, biennial inclusions, museum acquisitions, and critical reception. Then condition and restoration history, rarity within the artist’s body of work, and medium — oil on canvas tends to outperform works on paper, which outperform prints. A piece held by a major museum carries a stamp the secondary market trusts. And timing matters: five-year-old comparables are stale.

Auction-house specialists also talk about “emotional value” — collector desire, bidding-war dynamics, personal resonance. It can push hammer prices well past any rational estimate. You can’t model that directly, but you can pick up its shape indirectly through auction-house estimates.

The dominant valuation method in practice is comparable sales analysis: find recent auction results for similar works by the same artist and adjust for differences. An XGBoost model is doing the same thing, just at scale and with more features than any human appraiser would track by hand.

The Paper’s Central Claim

#

Lee et al. make a counterintuitive argument: the visual content of an artwork explains very little of its price. Their visual-only model, using color, composition, edge density, and ResNet18 embeddings, gets an R² of about 0.055. That’s barely better than guessing the mean.

A model using only artist-level “social” features (career stage, exhibition history, past auction prices, ranking on ArtFacts) hits R² ≈ 0.73. Add the auction house’s pre-sale estimate as a feature and it climbs to 0.92.

In other words, the artwork barely matters. What matters is who made it and what the market has already said about them.

The paper’s secondary claim is that this gap widens further in emerging markets, by which they mean anything outside the established USA, UK, France, and Germany core. In those markets, social signals matter more and expert estimates are less accurate, leaving more room for algorithmic prediction to add value.

Reproducing the Paper

#

The brief was straightforward: reproduce the paper as a single-developer MVP. No production deployment, no live data pipeline. Faithful reimplementation, prototype-quality code, and a written report on findings.

The Data

#

The paper provides cleaned CSVs as supplementary material:

The whole thing is about 5 GB. It fits comfortably in RAM, and XGBoost training on a dataset this size takes under five minutes on a laptop CPU. No GPU needed for the core model. Gradient-boosted trees on tabular data at this scale are nearly free to train, which is easy to forget if you’ve spent the last few years in neural-net land.

Features

#

The model uses 38 features split across three categories.

About the artist (30 features):

• Demographics: age, gender, education level, top-school flag.
• Career: ArtFacts ranking, solo shows, group shows, biennial inclusions, awards.
• Collections: counts of private and public collections.
• Price history: mean, median, max, and min from the artist’s last 5 and last 10 sales.
• Size-adjusted price history (price per square inch).
• Geography: where the artist works and lives, encoded as country flags.
• Match flags: does the artwork’s genre match the artist’s typical genre? Does the sale country match?

About the market (8 features):

• Auction house tier (1–4).
• Country and region price levels for that year (min, mean, median, max).

About the artwork itself (non-visual):

• Width, height, area in square inches.
• Medium category (painting, print, photo, sculpture, other).

Notice what’s absent: anything about the artwork’s actual visual content. That comes in only as a separate ablation study.

The Train/Test Split

#

Time-based, not random. Everything before May 2011 goes into training (~80%, ~27,360 records); everything after goes into the test set (~20%, ~6,840 records). Random splits would leak future information through the artist’s price-history features. If you scatter one artist’s records randomly across train and test, the test rows have already “seen” each other’s prices through the rolling windows, and your R² gets artificially inflated.

It’s the kind of thing that’s obvious once you see it but easy to miss on the first build.

The Model

#

XGBoost regressor, predicting log10(price_usd). Hyperparameter search over max_depth and learning_rate against a held-out validation slice. Two model variants:

1. Without expert estimates. Target R² ≈ 0.73.
2. With expert estimates. Target R² ≈ 0.92.

The “with estimates” variant uses the auction house’s pre-sale low and high estimates as additional features. Those two estimates alone, used by themselves, get R² ≈ 0.90. Adding the social features on top picks up another 0.02. That’s small in absolute terms, but it’s the part of the model doing real predictive work beyond what the experts already know.

What I Aimed For

#

I wasn’t trying to beat the paper. The goal was to land within ±0.03 of their R² values across all conditions. For the headline numbers (~0.73 metadata-only, ~0.92 with estimates), reproducibility is good. XGBoost is deterministic with a fixed seed, and the features are well-specified. I expected drift in two places: the visual-feature ablation, where small differences in PCA dimensions or image preprocessing can move things, and the emerging-market split, where there are only 4,346 records and the noise floor is higher.

Why Visual Features Barely Help

#

This was the most interesting result for me. The paper’s visual pipeline extracts 8,971 numbers per image:

• GIST descriptor (960 dims): overall spatial layout.
• Histogram of Oriented Gradients (2,915 dims): edge structure.
• Color histogram (4,096 dims): palette breakdown.
• ResNet18 features (1,000 dims): high-level pretrained embedding.
• Colorfulness (1 dim): vividness scalar.
• Complexity (1 dim): edge-density scalar.

Compress all that with PCA and feed it to XGBoost, and you get R² ≈ 0.055. Color alone gets 0.056. Edge structure gets 0.029. The neural-net embedding gets 0.009, basically zero.

The clean explanation is that auction prices are set at the level of the artist, not the individual work. Two paintings by the same artist sell for similar amounts regardless of what’s on the canvas, because what’s being priced is the signature.

You can see why this would be true if you’ve ever read auction catalogue notes. They spend almost all their words on provenance, exhibition history, and comparable sales. They barely describe the work itself.

If you take that 5% number seriously, the aesthetic content of a work is almost decoupled from its market value. Whatever the market rewards, it isn’t what’s on the canvas. A model that understood art at the pixel level would predict prices worse than one that only knew the artist’s CV.

Phase 3 Was Conditional

#

The paper’s image-link column points to URLs that were valid in 2012. By 2026, most are dead. The plan I wrote up flagged this risk on day 8: pull a hundred random URLs and see how many resolve. If more than half were gone, skip the visual phase entirely and document why.

Visual features only explain about 5% of price variance anyway. Spending two weeks fighting bit rot to confirm a number that small isn’t a good trade. Better to write up the dead-link finding as part of the report and move on.

Established vs. Emerging Markets

#

The paper trains separate models for established markets (USA, UK, France, Germany) versus emerging markets (19 other countries). The headline finding:

Two things stand out. First, social signals matter more in emerging markets, not less. I’d assumed established markets, with their richer data, would show better social-feature performance, but it’s the opposite.

Second, expert estimates are less accurate in emerging markets — that’s the 0.916 vs 0.859 gap once estimates are added in. In an established market, an algorithmic prediction has to compete with a specialist at a major auction house who has decades of comparable-sales data behind them. In an emerging market, that specialist has thinner data and the algorithm has more room to add value.

If you ever wanted to commercialise a model like this, emerging markets are where it would earn its keep.

Limitations Worth Stating

#

This is a paper reproduction, not a production system. It has no live data pipeline — the model trains on 1996–2012 auction data and never updates. There’s no deployment; the outputs are notebooks and a report, not a prediction API. There’s no drift detection, so once trained, the model has no idea when the market has changed. And the dataset is frozen: crypto art, NFTs, and post-COVID market shifts simply don’t exist in it. If you wanted to predict prices at a Korean auction house, you’d want auction-specific features and possibly a separate model for the Korean market — nothing here specialises that far.

The model also reflects historical patterns. If the contemporary market changed structurally around 2015 (and there are arguments it did, with art fairs becoming a major primary-market venue and a new generation of collectors entering), then the 1996–2012 patterns may not generalise.

From Paper to Platform

#

Reading the paper changed how I thought about the second project. The platform was originally framed as a crowdfunding marketplace for art exhibitions. Artists secure funding for upcoming shows, and investors get exposure to emerging artists earlier than the auction market typically allows.

The product surface is deliberately simple. Artists post upcoming shows that need funding (venue, dates, expected works). Investors back specific shows in tiered amounts ($100, $500, $1k, $5k) and share in the upside when the work sells. AI agents handle most of the artist-investor chat so that neither side has to be online for the conversation to keep moving. That’s particularly useful when a Korean gallery is talking to a U.S. collector across a 14-hour gap.

Once it sinks in that the artist is the asset and not the artwork, the data model has to change to match. What you need to capture is who has owned each work, where it has been shown, what comparable works have sold for, and who else owns work by the same artist. Ownership chains, institutional recognition, auction comps, collector networks — that’s what a knowledge graph is for.

The data model is small on purpose: artists, artworks, auction sales, ownership periods, and a provenance log for the data itself, so every record can be traced back to where it was scraped from. That last part sounds like bookkeeping, but with scraped data it’s what lets you trust the graph at all.

The mobile app renders all of this as a force-directed graph. A time-range slider lets you scrub through years and watch the network evolve: which collectors entered when, which artists got picked up by which museums, which works changed hands during the 2008 dip.

Each kind of entity gets its own shape and colour. Artists are diamonds, artworks are rounded rectangles, auction houses are hexagons, and the different kinds of owner (collectors, dealers, museums, estates) are circles in different colours.

The shapes aren’t decorative. When you zoom out to a few hundred nodes the silhouette tells you what type of entity you’re looking at without waiting for labels to render. A diamond surrounded by circles is an artist with a collector network. A hexagon connected to many diamonds is an auction house that handles a roster of artists. You can read the structure of a market at a glance.

A second tab shows the same data on a timeline: ownership periods as horizontal bars, sales as point events. Same underlying graph, different lens. Useful when you want to see the sequence of who held what, rather than the network shape at a single moment.

The platform isn’t itself a price-prediction tool. It’s the data layer underneath one. If you wanted to feed something like the Lee et al. model with live, current data instead of frozen 2012 CSVs, this is the structure you’d want.

Crowdsourced Valuation as a Game

#

The piece I haven’t built yet, and the part I’m most interested in, is turning art valuation into a game.

The Lee et al. paper takes auction-house pre-sale estimates as a feature and gets a big R² lift from them. Those estimates are valuable because they’re the aggregated judgment of trained specialists who have seen thousands of comparable works and have skin in the game. But auction-house specialists are a narrow, expensive resource. There are a few hundred of them globally, they work on specific consignments, and they don’t touch the long tail of artists nobody is consigning yet.

The question I keep coming back to is whether you can synthesise a comparable signal from a much wider, cheaper pool of judgments.

The rough design:

• Show a user an artwork: image, dimensions, year, artist name, brief CV.
• Ask them what it would sell for at auction.
• Let them pick a price bracket, or guess a hammer figure directly.
• Reveal the actual sale price after they commit.
• Score them with a Brier-score-style accuracy rating over time.
• Surface a leaderboard, daily streaks, and badges for hot streaks.
• Weight each user’s future predictions by their historical accuracy.

It’s a prediction market for art prices in the form of a guessing game. The loop is the same as a geography guessing game or online chess puzzle ratings: repeatable, scorable, with feedback you can build skill against. People who guess well rise on the leaderboard, and their future guesses count for more in the aggregated signal.

The model side is where this gets useful. A weighted aggregation of those guesses becomes a feature you can feed into XGBoost alongside the social signals. If the crowd’s accuracy-weighted median guess correlates well with hammer prices, you have something close to a synthetic auction-house estimate for works that don’t have a real one. That’s exactly the gap on the long tail of artists where the Lee et al. model needs the most help.

There’s also a cold-start angle. The model trains well on artists with rich price histories and badly on artists with three sales to their name. Three sales plus a thousand crowd guesses is at least something to work with. Crowdsourced valuation is a way of generating training signal for the cases the underlying data doesn’t cover.

Gamification matters here because the only way to make the crowd reliable is to make participating fun enough that people do it a lot. Single-question forms get you noisy data from people who clicked through once. A daily streak with a leaderboard and a calibration badge gets you the same person making 500 carefully considered predictions over a year. Volume plus self-selection (good predictors stay, bad predictors get bored) is what gives you a signal rather than noise.

There are design questions I’d need to answer before building any of it. How much do you show the user — just image and CV, or comparable sales too? More context means better-informed guesses, but past a point the user is mostly regurgitating what you’ve already shown them. How much price feedback do you give? Reveal the exact hammer, a range, or just whether they landed within ±20%? Too granular and you train people to anchor on specific numbers; too vague and they can’t calibrate. Then there’s leaderboard gaming: players will gravitate toward artists they already know, and a Banksy guess is mostly trivia rather than skill. Probably the fix is forced random sampling, the way language-learning apps pick lessons, plus a separate ranking for “blind” rounds where the artist’s name is hidden. And hindsight bias is unavoidable — once a user knows a Basquiat sold for $110M, they can’t un-know it. The supply of fresh, unseen artworks is what keeps the loop honest, and that supply is finite per week.

The gamification framing also pulls the platform’s two halves together. The crowdfunding side rewards investors when shows perform well financially. The guessing-game side rewards anyone, paying investor or not, for being good at calling prices. Both are versions of the same idea: let the crowd’s collective judgment turn into a tradeable signal. One trades capital, the other trades attention. Players who develop a real edge could eventually graduate to the investor side, bringing a verifiable track record of price-calling accuracy with them. That’s a better filter than “knew the right gallerist.”

What I Took Away

#

Pre-sale estimates are very good. Auction houses get a lot of grief for opaque pricing, but their estimates capture something close to 90% of price variance on their own. Whatever specialists are doing, they’re doing it well. And yet the artwork itself barely matters statistically — which is uncomfortable if you care about art for aesthetic reasons. The market isn’t pricing what you see. It’s pricing what other people have already paid for adjacent work.

On the modelling side, two habits earned their keep. Time-based splits are the only honest way to evaluate price models; random splits give you flattering R² values that don’t survive contact with production. And gradient-boosted trees are still the right tool here — XGBoost beats every neural baseline in the paper, and for tabular data at this scale, with this much engineered feature structure, there’s no reason to reach for a transformer.

The commercial observations: the interesting opportunity is in emerging markets, where expert pricing is thinnest and algorithmic prediction has the biggest gap to fill. And the crowd is an underused data source. The single biggest feature in the Lee et al. model was an auction house’s pre-sale estimate; if a calibrated crowd can produce a comparable signal for the long tail of artists, that’s a real opening, both as a model input and as a product in its own right.

The two projects ended up more complementary than I planned. The paper reproduction taught me what predicts prices. The platform work taught me what data structure you’d need to put that knowledge to use. The gamification idea ties the two together: the knowledge graph supplies the artworks and historical sales, the guessing game generates a crowd-derived estimate feature, and the model consumes that feature alongside the social signals to produce predictions for artists who would otherwise be invisible to it.

None of this is finished. The paper reproduction is a working prototype with a written report, the platform is a demo with seeded data, and the crowdsourced game only exists as the design notes you just read. But the connecting idea is consistent enough that I think the right shape is reasonably clear: price the artist rather than the artwork, aggregate the crowd rather than relying only on experts, and treat valuation as something the market produces collectively rather than something specialists hand down.

That’s the version I’d ship next, given the time to build it.

That’s the obvious flaw in views and upvotes: they reward whatever’s already popular. Fresh content starves at the bottom of the feed, and the platform slowly turns into a rerun channel. Ranking a feed well is one of the quietly hard problems where I work, so I’ve spent a fair bit of time thinking about which other signals are worth trusting.

Watch what people do, not what they tap

#

Explicit feedback is scarce and biased; behaviour is plentiful. Time on page and scroll depth tell you whether someone actually read the thing or bailed after the first paragraph. Revisits are even better — coming back to a piece is a stronger endorsement than any upvote. And a fast exit is a useful negative signal: the content promised something the reader didn’t get.

Signals baked into the content itself

#

Good content doesn’t always collect early likes, but it usually shows its quality in other ways. Novelty is one — does the piece cover ground the platform hasn’t seen? Structure is another; clean formatting, decent grammar and clarity correlate with quality more than we’d like to admit. An author’s track record is a fair prior too, judged on how their past work held readers rather than on raw like counts. Early comments help as well: three genuinely positive comments beat thirty reflexive upvotes, and a bit of semantic analysis can flag content that fills a gap the platform has been missing.

Borrow signals from outside

#

The wider internet tells you what’s resonating right now. Content that lines up with trending search keywords has built-in relevance, and quick publishing on a rising topic deserves a boost. What’s buzzing on Twitter or Reddit is often a preview of what your own users will want next — with a little prediction you can promote matching fresh content before the wave instead of after it. Your own search box is underrated too: if users keep searching for a topic, or a piece pulls steady traffic in from search engines, that’s relevance you didn’t have to guess at.

Blending the signals into one score

#

Here’s the idea in a few lines of Python. It’s an illustration, not a production system. Each signal is normalised to a 0 to 1 range so that one with big raw numbers can’t drown the rest, a weighted sum turns them into a single score, and a time decay gives a new post a fair shot against last month’s hit.

WEIGHTS = {"read_depth": 0.3, "revisits": 0.25, "quality": 0.25, "early_comments": 0.2}
HALF_LIFE_HOURS = 48  # a post loses half its score every two days

def normalise(values):
    lo, hi = min(values), max(values)
    return [(v - lo) / (hi - lo) if hi > lo else 0.0 for v in values]

def rank(items):
    """items: dicts holding raw signal values plus "age_hours"."""
    norm = {name: normalise([item[name] for item in items]) for name in WEIGHTS}
    scores = []
    for i, item in enumerate(items):
        base = sum(weight * norm[name][i] for name, weight in WEIGHTS.items())
        scores.append(base * 0.5 ** (item["age_hours"] / HALF_LIFE_HOURS))
    order = sorted(range(len(items)), key=lambda i: scores[i], reverse=True)
    return [items[i] for i in order]

The weights are guesses until the tests below say otherwise. Views and likes can still go in; they just become one input among several instead of the whole score. The half-life decides how quickly old posts sink, which is a topic of its own: I went into it in how feed ranking algorithms decide when to bury old posts. Real systems usually learn the weights with a model rather than picking them by hand, but the shape is the same: many signals in, one number out, sort.

Then test it honestly

#

However clever the signals, A/B test them — show new content to a slice of users and compare its engagement against the incumbents. And watch how things spread: shares, mentions and embeds, on and off the platform, say more about value than a view counter ever will.

No single metric survives contact with reality. The rankings that actually work blend behaviour, intrinsic quality, timeliness and honest experiments, and no one signal gets the final word.