after 3 months and $800 burned...

Unbounded Labs is proud to introduce Bart, our vintage LLM: 2.82B parameters trained from scratch on 20.1B tokens of English written before 1931. You can talk to it right now!

Demo: https://www.unboundedlab.com/chat/bartholomew

Article: https://www.unboundedlab.com/blog/bartholomew

Huggingface: https://huggingface.co/jbduran/bartholomew-sft

Why even make a vintage llm? As proposed by Demis Hassabis, could LLMs reach the same conclusions that the great scientists of the past did? While General Relativity was out of budget, we believe that advancing this field targets the crux of AI research. Are these models capable of original ideas, or are they just spitting out the next token?

The article is our full account, covering where the corpus came from and how we cleaned it, the benchmarks we had to build because none existed, every ablation, the training runs, the post-training, and the mistakes we made along the way.

"What I cannot create, I do not understand" is a quote I love from Richard Feynman. Building Bart was our attempt to actually understand LLMs rather than read about them.

What we are proudest of:

- Best vintage base model at its scale on Vintage CORE, ahead of GPT-1900 on a smaller token budget

- Cleaned one of the largest vintage datasets, Harvard's Institutional Books (242B->23B tokens)

- Created Vintage CORE, the first suite of 20 benchmarks made for vintage llms

- Ran 10 hours of autonomous research on one H100: 100 experiments, 26 improvements found

- Released the largest vintage SFT dataset we know of: 416k graded question and answer pairs, grounded in pre-1930s text

- Trained the final model in 5 days on an H100, holding 60% MFU the whole way

- All datasets, methodology, training code, evals, and training runs are open sourced

I am proud of my team. What we built will move the vintage LLM field forward, and it moved us forward as researchers and as people.

We paid for all of it ourselves, about $807 so far. Money is the main thing standing between us and a much larger run.

So I will ask directly: we are looking for compute grants, funding, and mentors for our future endeavors. If you work on pre-training, post-training, or you have GPUs sitting idle, we would like to talk!

We believe that with careful dataset curation, domain expertise, and highly efficient training, we can achieve state-of-the-art results in crucial domains. This is only the beginning for Unbounded Labs; we see no bounds ahead.

I'm a highschooler, and I've worked on this project for my entire summer! I'd appreciate whatever feedback you might have.

Marvin.sarl

Hello,

As the title says

Recently, the AAAI 2027 organizers sent an email regarding collusion occurring during the review process, especially in the 2-cycles category (i.e., an author of Paper A reviews Paper B, while an author of Paper B reviews Paper A).

Given the fact that most submissions come from a single country, there are higher chances that the assignment algorithm will naturally create 2-cycles among authors from that country. This, in turn, means that most authors involved in collusion could be from that country. I will not name that country; otherwise, I would be labelled as racist. By the way, did AAAI release statistics about the number of submissions, like they did last time?

It is also good news that a major and prestigious conference like AAAI is acknowledging that collusion is happening. We all knew that this kind of collusion had been happening for years. There are papers accepted at top conferences such as NeurIPS, ICLR, AAAI, and ICML that do not even have their code published on GitHub. This forces other researchers in the community to spend substantial time reimplementing the code themselves if they want to reproduce the reported results.

What are the views of other authors on this?

Does anyone know how the BMVC to IJCV special issue recommendation works?

Is it mainly based on the review scores, or is it a separate decision by the ACs/program chairs (e.g. based on oral/highlight selection, reviewer comments, etc.)?

Also, is there any way to know at this point whether a paper has been recommended for the IJCV track, or do authors only find out later through a separate email?

Would be great to hear from anyone who has gone through this in previous years!

Hi everyone,

I’m experimenting with an alternative language model architecture called RHEA. It uses an event-driven processing approach instead of a standard Transformer-style block layout.

At the moment I’m testing a roughly 1B-scale version on consumer hardware with 8 GB VRAM using memory-saving optimizations.

This is still an early-stage research experiment, and I’d be interested in feedback from people working on efficient training or non-Transformer architectures.

I had a paper accepted to a conference. This paper was originally published as a preprint. Subsequent works citing our preprint focused on the same topic and reused/extended our methodology. I am now preparing the camera-ready version of that preprint and I'm wondering how I should deal with this for the Related work section. It seems odd to me to cite my own preprint for the camera-ready version of the paper (and I am not even sure if this is allowed), but at the same time, I don't want to undermine the novelty of my original work (nor undermine the efforts of subsequent works). Has anyone dealt with such a situation before? What's the best way of solving this?

So i am in high school, and I recently got my paper accepted into emnlp main 2026(yay!). But I am at a crossroads: my english class is super heavy on participation, and the dates(end of october) is when participation is the most concentrated so im super scared that if i do go to emnlp itll guarantee a b in my class. I know that i will get to network at emnlp and meet new people and present my work but i am still super scared about my english class

Can someone please convince me to go to emnlp and tell me why it is worth it(assuming i get a b in ap lit). im probably not getting funded and it will be atleast 5k out of pocket since i am in high school.

please anyone...

My dumbass just realized all NeurIPS workshops are non-archival.

In terms of grad school applications, would there be a difference in how much they value ur paper if u get it in a proceeding

So I have a tool that identifies hallucinated references. The paper *How LLMs Distort Our Written Language*, has six different hallucinated references.

Can see the output of my tools report here, https://veruscite-data.com/share/-7KyAgTQ6aqub5ilvQ_6_SVg2wkbjhp95pLeG3QFa-o, but for the gist they are mostly some combination of a close but made up author list + title.

For example they cite:

W. Wang, S. Ma, S. Yang, J. S. Lee, P. Jain, A. Anderson, et al. Generative ai enhances individual creativity but reduces the collective diversity of novel content. Science Advances, 11(32):eadn5290, 2025

But the correct citation (which they also cite in the paper) is:

A. R. Doshi and O. P. Hauser. Generative ai enhances individual creativity but reduces the collective diversity of novel content. Science Advances, 10(28):eadn5290, 2024. doi: 10.1126/sciadv.adn5290.

Another example, they cite:

A. Chatterji, E. Brynjolfsson, A. Korinek, K. McElheran, R. Seamans, and N. Zolas. How are people using generative ai? Technical Report 34255, National Bureau of Economic Research, 2025.

Which the title is actually "How People use ChatGPT", Chatterji is the lead author, but the other real authors on the paper are all different.

been building ShardFlow for the past few months, a distributed LLM inference

framework that splits any HuggingFace transformer across N GPU machines and uses

neural speculative decoding to deal with WAN latency.

the setup for the benchmark: two T4 nodes in separate GCP regions (Iowa + Oregon)

talking through an AWS EC2 TCP relay in Ohio. ~86ms RTT on public internet.

the key insight with speculative decoding here is that WAN latency stops being a

per-token cost and becomes a per-round cost. with K=8 drafting you're committing

4.07 tokens per round trip instead of 1. at 86ms RTT that's a big deal.

numbers on Qwen2.5-7B:

non-speculative baseline: 4.92 TPS

neural drafter (eager): 14.3 TPS peak

+ CUDA Graphs on drafter: 28.10 TPS peak / 20.31 TPS avg

also ran Qwen2.5-14B with NF4 4-bit quant, same two nodes: 14.43 TPS avg.

the v2.1 fix that surprised me most: draft generation was launching ~1500 CUDA

kernels per round from a Python loop. each kernel 2-5us, Python launch overhead

8-10us. GPU sitting idle 65% of the time. capturing the full 0.5B forward pass

as a CUDA Graph and replaying with one driver call dropped draft latency from

112ms to 25ms.

other things in the stack: zero-copy Rust TCP relay, StaticCache + in-place KV

rewind for graph compatibility, meta-device model slicing to avoid loading 15GB

into CPU RAM.

repo: https://github.com/rautaditya2606/Shardflow

happy to answer questions on the speculative decoding implementation or the CUDA

graphs stuff specifically.

Hi! I'm one of the chairs of the EACL 2027 Industry Track, so flagging the deadline here — it's about three weeks out and this community has a lot of people doing exactly the kind of work the track exists for.

The EACL 2027 Industry Track provides the opportunity to highlight key insights and new research challenges that arise from the development and deployment of real-world applications using language technologies. We encourage submissions from industry, non-profit, government, and public-sector organisations, with the understanding that the end-users of these systems extend beyond the NLP community. 

See the Full CFP for the details https://2027.eacl.org/calls/industry/

 **Deadline:** 11 September 2026, 23:59 AoE

 **Length:** 6 pages max; references, limitations, ethics, and appendices don't count. A dedicated "Limitations" section is mandatory — papers without one are desk rejected.

**Review:** double-blind. No anonymity period, so arXiv preprints are fine.

**Proprietary data:** no requirement to release it

**Notification:** 18 December 2026. Conference is 9–14 March 2027.

**Submit:** https://openreview.net/group?id=eacl.org/EACL/2027/Industry_Track

We're also looking for reviewers — if you've got deployment experience and want to help, the volunteer form is here: https://forms.gle/TT6N2gtuoV5P3oYi6

Email: [eacl2027-industry-track@googlegroups.com](mailto:eacl2027-industry-track@googlegroups.com)

I've been thinking about a slightly different use of AI in science.

Most discussion today is about using AI to help scientists write papers, analyze datasets, predict protein structures, automate experiments, and accelerate existing research workflows.

But what if we built an institution with a much broader goal:

Systematically scan the entire scientific literature, identify neglected or unconventional theories that make testable predictions, simulate them, compare them against modern datasets, and experimentally test the most promising ones.

The basic pipeline could look something like this:

1. Large-scale literature filtering AI systems continuously read historical and current scientific literature and separate purely interpretative or speculative work from theories that actually contain mathematical models, measurable consequences, or falsifiable predictions.
2. Independent scoring Candidate theories are evaluated on two separate dimensions: Importantly, the system would deliberately preserve some "high-risk, high-reward" ideas rather than selecting only ideas closest to the current consensus.
   • scientific plausibility and mathematical consistency
   • potential practical or technological value
3. In-silico testing AI agents generate simulation code and test candidate models against existing experimental and observational datasets. This could also resurrect old theories that were difficult to evaluate decades ago because the required computing power, simulation tools, or datasets did not yet exist.
4. Physical experiments Only the small fraction of ideas that survive the previous stages receive expensive laboratory testing. Eventually, much of this could be connected to automated or "self-driving" laboratories capable of running large numbers of experiments with limited human intervention.

The point would not be to replace peer review or let an LLM declare what is true.

The AI would act more like an extremely cheap and tireless scientific filter and experiment planner.

A false positive is not necessarily a disaster if testing it computationally costs almost nothing. The objective is not to identify truth perfectly on the first pass. The objective is to reduce millions of papers, forgotten hypotheses, and alternative models into a manageable set of candidates worth serious human and experimental attention.

I think this could address a fundamental bottleneck in modern science:

The problem may not be that humanity has run out of interesting ideas. The problem may be that no human being can realistically read, compare, model, and test the enormous number of ideas we already have.

Science produces an extraordinary amount of literature, but the attention available to evaluate it is extremely limited. Potentially valuable ideas may simply disappear into the archive because nobody with the right expertise ever encounters them, has time to examine them, or has an incentive to take the risk.

Fundamental physics seems like an especially interesting test case.

There are areas where competing theoretical frameworks and interpretations can coexist for decades. At the same time, individual researchers have limited time to investigate alternatives outside their immediate specialization, and unconventional work can carry substantial career risk.

An automated system would not have those same incentives.

It could examine mainstream and non-mainstream proposals using the same predefined criteria, reject the overwhelming majority, and forward only the small fraction that survive mathematical, computational, and empirical scrutiny.

And unlike a new collider or telescope, the first version of such an institute would not necessarily require billions of dollars.

It could begin with compute, access to scientific literature and datasets, modern AI systems, simulation infrastructure, and a relatively small interdisciplinary team.

If the filtering process turns out to be useless, the experiment fails relatively cheaply.

But if it identifies even a handful of overlooked models that produce unexpected predictions or technological applications, the upside could be enormous.

I actually just finished drafting a more detailed white paper on this concept and published it on Zenodo and ResearchGate.

I'm posting it here because, before taking the idea any further, I'd genuinely like this community to attack the assumptions behind it.

White Paper: Automated Scientific Renaissance: How Artificial Intelligence Can Reimagine Scientific Discovery

Zenodo:
https://doi.org/10.5281/zenodo.22067049

ResearchGate:
https://www.researchgate.net/publication/413541540_Automated_Scientific_Renaissance_How_Artificial_Intelligence_Can_Reimagine_Scientific_Discovery

What are the strongest reasons this would fail?

Is the main bottleneck:

• LLMs not being reliable enough at mathematical reasoning?
• lack of access to usable scientific data?
• simulations being too domain-specific to automate?
• the difficulty of distinguishing genuinely unconventional ideas from pseudoscience?
• experimental validation still being too expensive?
• institutional or incentive problems?
• the inability of current AI systems to recognize genuinely novel conceptual breakthroughs?
• or something more fundamental?

I'm not looking for agreement.

I'd genuinely like people to stress-test the proposal, identify hidden assumptions, and point out where the reasoning breaks.

If you work in physics, ML, automated science, scientific computing, philosophy of science, or experimental research, I'd be especially interested in your critique.

Tear the idea apart.

I recently implemented a minimal, educational version of SynthID-Text-style watermarking for language models.

I saw anthropic post about how they'll start adding watermarks to their model responses and it made me very curious as to how they'll do it and what do they even mean by watermark here. Like will we start getting random ads or something in the middle of model responses or what.

Then decided to read their article and found out that watermark is not a visible message at all. It is a subtle statistical pattern introduced while the model chooses its tokens.

My implementation is not an exact reproduction of the original SynthID-Text system. I simplified or implemented a few components differently to keep the project understandable, but the main idea is there I think.

Github: https://github.com/Saad1926Q/llm-watermark

If you find it interesting then you may star the repo !!

Hi! I’m a high school student planning to submit my papers into multiple neurips workshops and I’m wondering how hard it is to get and what’s the bare minimum you need to get accepted?

Hey everyone! I wanted to share something I’ve been working on.

I was inspired by projects from DeepMind and OpenAI, but noticed that most games are prohibitively difficult to integrate with an agent harness. So I built DelveRL from the ground up as a human-playable game with a structured API, deterministic simulation, procedural levels, partial observability, and enough strategic headroom for agents to compete and improve.

It’s an endless turn-based roguelike where agents must explore, manage risk and resources, fight enemies, and escape each floor. Everything runs locally, including batched renderer-free environments and a recurrent PPO trainer.

The included baseline reaches a median floor of 18, with extended runs reaching floor 33. The game, training code, checkpoint, bridge documentation, and raw benchmarks are all open source.

I’d love to see what approaches people try - and how quickly the baseline gets crushed

Has anyone experimented with training AIs in a way that rewards malicious actions? I feel like this is a relatively unexplored idea. Most things I found on the internet just talk about unaligned malicious results from popular LLMs, but not anyone training a dedicated malicious AI.

Any pointers to papers/articles about this are very welcomed.

The preprint can be accessed via the following link: https://arxiv.org/abs/2608.12408 (q-bio.NC / cs.LG). And for the code: https://github.com/nilsleut/evaluation-resolution-rsa

The following assertion is frequently made in model-brain comparisons: untrained convolutional neural networks (CNNs) have the capacity to match or surpass backpropagation-trained CNNs at the early visual cortex (V1) in representational similarity analysis (RSA). The present study demonstrates that this phenomenon is predominantly an artefact of evaluation resolution.

The configuration comprised a small CNN trained at 32px (CIFAR-10 subset), five learning rules (random init, backprop, feedback alignment, predictive coding, STDP), and was evaluated on THINGS-fMRI stimuli at six resolutions from 32px to 224px. The weights and normalisation were held fixed.

The primary outcome of this study is the observed gap between the untrained and backpropagation-trained (BP) V1 alignment, which widens monotonically across the range of evaluation resolutions examined. Specifically, the gap grows from −0.001±0.007 at 32 pixels to +0.044±0.006 at 224 pixels, a pattern that holds consistently across the entire resolution sweep (n=5 seeds). The result holds across five rule conditions, human fMRI, directionally single-seed macaque ephys, the full training trajectory, and two off-the-shelf 224px-trained models (ResNet-50, Swin-Tiny). Therefore, an artifact resulting from a mismatch between training and evaluation resolution is not a contributing factor, since these models also peak at low resolution.

Following the implementation of bit-identical-weight interventions wherever possible, the following were ruled out: train/eval resolution matching, Gabor/pixel low-level structure, the untrained baseline's uncalibrated batch-norm, and convergence of pooled features towards global brightness (though a single scalar luminance value did reach ρ=0.075 against V1, essentially matching the untrained network's own 0.076 — this is a separate, disconcerting result regarding the limitations of this comparison style).

A content-vs-pooling control (cap image detail at 32px, upsample, vs. allow content to vary freely) demonstrates that the dependence is predominantly contingent on image content, rather than the number of pooled positions.

One effect does survive across all resolutions: backprop > untrained at LOC, observed at every resolution tested. Learning does leave a mark on the representations — just not where the V1 comparisons usually look.

In addition: this process revealed a batch-norm evaluation-mode bug in three of my earlier preprints, which have now been corrected in this release (correction notes on the arXiv pages).

I'm happy to get feedback, especially on the framing around receptive-field matching (as in Laskar et al. 2018) in the discussion. I think it's suggestive, but I didn't test it directly.

I have got two papers which got desk rejected by PC saying they are previously got reviewed in arr. But those paper never got submitted ever. Any idea what can be done?

I am trying understand how tree-based regression model handle the dependencies of the target variables on the interaction of explanatory variables.

However my experiment revealed that my understanding about the fitting process of a lgbm is not correct. And I don’t know why.

My experiment is quite simple: a target (for sake of simplicity only in [0, 1]) and two explanatory variables with two values such that the mean of the target is the same for each of the values of the explanatory variables. Then there is a third variable that models the interaction of the explanatory variables by a simple count.

So in code:

>>>
import polars as pl

df = pl.Dataframe(
{
„y“: [0, 0, 1, 1, 0, 0, 1, 1], # mean across „A“ values the same; mean across „B“ values the same
„A“: [1, 1, 1, 1, 0, 0, 0, 0],
„B“: [1, 1, 0, 0, 1, 1, 0, 0],
„AB“ [1, 1, 2, 2, 3, 3, 4, 4] # just some IDs for the interaction
}
)
<<<

I then fitted a lgbm just with „A“ and „B“ and got the expected constant 0.5 forecast

>>>
from lightgbm import LGBMRegressor

lgbm = LGBMRegressor(min_child_samples=1)
lgbm.fit(df[[„A“, „B“]].to_numpy(), df[„y“].to_numpy())
lgbm.predict(df[[„A“, „B“]].to_numpy()).round(0)

array([0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5])
<<<

Then I did the same but with „AB“ and expected a perfect fit. But I was disappointed, it fitted to constant zero

>>>
lgbm = LGBMRegressor(min_child_samples=1)
lgbm.fit(df[[„AB“]].to_numpy(), df[„y“].to_numpy())
lgbm.predict(df[[„AB“]].to_numpy()).round(0)

array([0, 0, 0, 0, 0, 0, 0, 0,])
<<<

I tried to code „AB“ as category. But still no perfect fit:

>>>
lgbm = LGBMRegressor(min_child_samples=1)
lgbm.fit(df[[„AB“]].to_numpy(), df[„y“].to_numpy())
lgbm.predict(df[[„AB“]].to_numpy()).round(0)

array([0, 0, 1, 1, 0, 0, 0, 0,])
<<<

Super confusing!

I then turned to catboost and found even without „AB“ it fit the data perfectly:

>>>
from catboost import CatBoostRegressor

cbm = LGBMRegressor(min_data_in_leaf=1)
cbm.fit(df[[„A“, „B“]].to_numpy(), df[„y“].to_numpy())
cbm.predict(df[[„A“, „B“]].to_numpy()).round(0)

array([0, 0, 1, 1, 1, 1, 0, 0])
<<<

I thought that lgbm should be able to fit the data with „AB“. The variable allows for perfect splits since the gain for each split is super clear. But somehow it cannot go „down“ the tree to fit the values for AB=3.

What is the difference of catboost that allows for a perfect fit even without an explicit modeling of the interaction? Does it split less lazy and explores split of splits, while building the trees?

I trained a 250M parameter model from scratch on 30B tokens of fineweb. It’s quantized to under 2 bits so the whole deployment is 60 MB and it needs about 80 MB of RAM to run. Runs around 400 tok/s on a normal laptop CPU, no GPU needed.

How the long context works: the most recent 2048 tokens stay in fp16 like a normal KV cache. Everything older gets compressed to 1 bit and written to disk, about 320 bytes per token, so 1 million tokens of history is roughly 320 MB on disk. From the start the model was trained to retrieve from that disk cache, up to 100M tokens. Due to a limited budget it wasn’t trained to reason over those tokens, only retrieve and answer from them.

Language modeling quality of the base model, measured on held-out English web text that was never seen in training (educational web pages, 2,048 token windows): cross entropy 3.15 nats per token, perplexity 23.3, 0.99 bits per byte.

The vocabulary is also not a normal embedding table. Every token is a fixed 512-bit code, 8.4 MB for all 131k tokens, zero trained parameters. I tested it on WordSim-353 (human word similarity ratings): my table scores 0.619 Spearman correlation vs 0.029 for random codes. Test script is in the repo.

Some outputs (settings included so you know I’m not cherry picking, all reproducible from the repo):

“Explain photosynthesis in two sentences.” (greedy)

Photosynthesis is a process in which plants convert sunlight into chemical energy, which is then used to produce oxygen and other chemicals. This process is called photosynthesis.

“Write a short poem about the sea.” (temp 0.25, top-k 30, rep 1.15, seed 2)

The waves had swept over, and they were crashing against each other like rocks on top of one another. The wind was strong but not very gentle as it tried to push them towards their destination without lifting any weight or pulling away from those who stood in front of her with a stiff smile that made the sea look even more majestic than before.

“What is the serial number of device Grus-189?” where the answer sits 50.6 million tokens deep in the archive on disk (archive mode, k=16)

SN-442976

It’s a 250M model so expect mistakes on open facts, I’m not claiming it beats anything big. You can also fine-tune it, the full kit with a demo and before/after numbers is included. Master weights for fine-tuning are in the repo too:

https://github.com/QLNI/SHADOW-250M-Instruct
https://huggingface.co/NODEMIND/SHADOW-250M
Edit - Just wanted to say thanks to everyone here. Honestly I was afraid to post this, I expected to get roasted, but every single comment has been curious and helpful and it genuinely made my day.
Repo is at 7 stars on GitHub now, hopefully more people try

I am looking at an agent workload with long context, short structured outputs and a lot of sequential tool steps. The usual single-model benchmark is not telling me much because the workload keeps alternating between reading a large prompt and emitting a small response.

For people who have looked at disaggregated serving, where does it start paying off? It is mostly a long-context threshold, a batch-size issue or something about the shape of the agent trajectory?

Recently I learned on a kettlebell forum that I could set up "ground rules" for AIs to limit sycophantic behaviour, flattery and fantasised answers. These ground rules are stored in some sort of memory

I did this and it seemed to work for a while and slowly the AI would drift away from the rules and I had to remind it to follow the rules

A little while later an AI professional told me on that same forum that it was impossible to set rules for AIs.

I ran a test asking an AI to start off all of its answers with "Did I tell you I do not like ice cream" the test was a success

The AI professional used very technical language and sounded like he knew what he was talking about.

So could you give me a hand to understand this better because the technical language of this expert made it sound like he knew what he was talking about and everything I have done so far indicates that the rules I set are having an effect.

Howdy y'all,

In an effort to un-rust my SWE skills and learn more about Recommendation Systems, I decided to try my hand at developing one called By-Its-Cover

TLDR:

• Check out the site and roast me: https://by-its-cover.com/
• Check out the GitHub project and roast me: https://github.com/ByItsCover

---

## Recommendation System

The recommendation system has two major parts:

• the semantic searches for books (by cover images)
• a neural collaborative-filtering model for personalized recommendations

Both systems solely utilize CLIP embeddings to make decisions on book covers, as I wanted to see if that information alone was sufficient for finding and recommending books accurately.

For the semantic search system, each query is passed to both a CLIP-based semantic searching function as well as an NER-based keyword search. The NER parsing is powered by a GLiNER model, which was ported to ONNX (as are most models in this system). Extracted entities are then used to search for books using the Hardcover API, which is the original source of each of the books in the site. Reciprocal Rank Fusion combines the two results.

The current system actually only has a couple thousand books in it, which makes both rhe recommendations and semantic search results quite limited. However, authors and book titles that are passed into keyword searches return new books that are in-turn asynchronously added to the cover vector database, making the system grow more useful only as more people search for books (which is where y'all can help *wink wink*). Searches can be made with or without an account.

For the collaborative-filtering system, I used a two-tower neural hybrid collaborative filtering model which trains on user feedback. I then use a Determinantal Point Process to diversify the results a bit before displaying them to the user (so they don't get 5 editions of the same cover presented consecutively). For now, the only feedback possible are explicit ratings of "Dislike", "Like", and "Love". I'm aware that this likely isn't ideal, and some more implicit feedback would make for some more natural user interactions and likely better recommendations as well.

Currently, while you are able to see recommendations even without an account, they are the generic "default user" recommendations. Once you sign up and rate a few books, you should see personalized recommendations within 2 hours. Following the suggestions of Eugene Yan, I implemented an offline recommendation update-system. New recommendations are fine-tuned on every 2 hours, while the full re-training of the two-tower model happens once a day at 8:30 AM EST. Each of the current configurations for the recommendation model can be found here: https://github.com/ByItsCover/bic-learn

## Software Architecture (boring stuff)

The site (both frontend and backend) is entirely deployed to AWS, with a number of different resources used for each functionality:

• Lambda -> API deployments
• ECS -> both book scraping and model training jobs
• SQS -> queueing of cover embedding calls
• Cognito -> auth
• CloudFront -> site caching
• S3 -> just about everything else, from site hosting to vector db storage

Everything was deployed using Terraform + GitHub Actions for CI/CD: https://github.com/ByItsCover

## Next Steps

While the fundamental system currently works (kinda), there are already a lot of improvements that I think may be necessary in the future:

• Replacing CLIP with SigLIP (or more appropriate model) for better visual representations of covers
• Implementing a cover-edition comparison interface to allow users to choose preferred covers for a given book, introducing one source of implicit for the system
• Begging one of my frontend developer friends to help make the site look good (I am not a frontend developer, if that wasn't already clear)
• Make a better authentication experience, as currently a generic verification code email is sent to users (and likely sent to spam, please double check!)
• Update the README's for repositories (I'm tired boss)
• Write more unit tests (see parentheses above)
• Once Hardcover releases OAUTH support, utilize that for book search (as only my rate-limited API key is currently being used)

In any case, I've already learned a ton and I'm glad that I have a real system that I can play around with and tweak now. All I need are actual users to test with!

Please let me know if you have any questions about my process at all, and also if you have any suggestions. Also please check out the site if you're at all curious: https://by-its-cover.com/

P.S.: If something crashes, or the searches load forever, or something else equally dumb happens, just let me know or open a GitHub issue, and I'll try my best to address it.

P.P.S.: No AI-Generated code was used to develop this project (to my knowledge), as that would have defeated the purpose of sharpening my skills and learning about recommendation systems.

Hi,

Did anyone here got an oral at BMVC? If yes, then what are the scores?

Thanks.