# Hugging Face Projects at AI Tinkerers

> Canonical HTML: https://aitinkerers.org/technologies/hugging-face
> Markdown URL: https://aitinkerers.org/technologies/hugging-face.md
> Technology record last updated: 2026-09-18T15:13:53Z
> Generated: 2026-09-23T06:35:17Z

Hugging Face is the central, open-source platform and community for building AI applications, hosting over 300,000 models and datasets via the popular Transformers library.

Hugging Face functions as the 'GitHub for machine learning,' providing a massive, collaborative Hub for AI assets (models, datasets, and demos). Its core technology is the open-source **Transformers** Python library, which simplifies the use of state-of-the-art models (e.g., BERT, GPT) for various tasks: natural language processing, computer vision, and audio. The platform hosts over 300,000 models and thousands of datasets, streamlining the entire ML workflow from research to deployment via **Spaces** (interactive demos). This ecosystem makes advanced AI accessible, efficient, and reproducible for developers and enterprises globally.

- Official technology site: https://huggingface.co
- Public AI Tinkerers demos and talks: 41
- Result page: 1 of 2

## Recent Public Talks and Demos

### [Training/Generating Absurd Cat Standup Videos](https://la.aitinkerers.org/talks/rsvp_7-heCmu8l0U)

I will be using Python/LLAMA-3 model to train a Seinfeld Style Monologue Generating LLM model and use Veo 3 to automatically make Absurd Cat Standup Videos. -I first scraped all Seinfeld scripts from https://www.seinfeldscripts.com/ -I captured/cleaned/formatted monologue data from the scraped Seinfeld scripts. -I used Python/Ollama to train the Llama 3 8b model to make an LLM that can generate seinfeld style monologue by subject. -I used the output of the trained LLM to make cat standup videos through Veo 3.

- Event context: Aug 16 - AI Tinkerers LA: Beauty, Bytes, and Venice Beach Vibes 🌊✨🤖 — Los Angeles
- Public talk page: https://la.aitinkerers.org/talks/rsvp_7-heCmu8l0U

### [Job Seeker](https://paris.aitinkerers.org/talks/rsvp_rUKvMBG0Ezg)

I build a software to help to find a job

- Event context: Offstage w/ Docker feat ClickHouse — 2026-07-07 — Paris
- Public talk page: https://paris.aitinkerers.org/talks/rsvp_rUKvMBG0Ezg

### [Meet North Mini Code: Cohere's first model for developers.](https://montreal.aitinkerers.org/talks/rsvp_RFfBetDE0zk)

North Mini Code is a 30B parameter MoE coding model (3B active) that Cohere released June 9 under Apache 2.0, trained specifically for agentic software engineering. We will demo it live in OpenCode so you can watch it work through an agentic coding task end to end. Alongside the live agent session, we'll walk through the architecture and the post-training pipeline that got it there: two stages of SFT followed by async RLVR across terminal and SWE environments.

- Event context: AI Tinkerers Montreal - June Demo Meetup — 2026-06-17 — Montreal
- Public talk page: https://montreal.aitinkerers.org/talks/rsvp_RFfBetDE0zk

### [Teaching a robot to always win connect four via LeRobot](https://berlin.aitinkerers.org/talks/rsvp_HveawmqfJoQ)

I trained an autonomous robot arm setup using Hugging Face’s LeRobot framework that plays a game of Connect Four and is annoying as it always beats human opponents. The robot perceives the physical board state via a camera, calculates the optimal move, and executes the physical token drop.

- Event context: AI Tinkerers Berlin - June 17, 2026 — 2026-06-17 — Berlin
- Public talk page: https://berlin.aitinkerers.org/talks/rsvp_HveawmqfJoQ

### [Transformer-Diffusion model for molecular battery material generation](https://dubai.aitinkerers.org/talks/rsvp_SK0KgeEQ2Rc)

I built Simer Energy, an end-to-end generative AI pipeline that uses a hybrid Transformer-Diffusion architecture to autonomously design, physically relax and thermodynamically validate novel battery materials from scratch. For the demo, I will execute a terminal-based run of the by inputting strict material constraints (e.g., elemental bounds for a cobalt-free transition metal oxide, target stoichiometry, and symmetry parameters) into a fine-tuned model. I’ll show how the Transformer maps these constraints into a discretespace groups and passes it as a conditioning vector to a diffusion model. You will see the model denoise the 3D spatial atomic coordinates, followed by the critical "zero-strain" and then passing the raw generated structure directly into a Universal Machine Learning Force Field (CHGNet) to instantly relax the atomic coordinates, bypassing days of expensive DFT calculations and then run the relaxed structure through ALIGNN to validate its Energy Above Hull, resulting in a mathematically viable file generated in under three minutes.

- Event context: AI Tinkerers Dubai - May Demo Day — 2026-05-23 — Dubai
- Public talk page: https://dubai.aitinkerers.org/talks/rsvp_SK0KgeEQ2Rc

### [Towards Embodied AI with MuscleMimic: Unlocking full-body musculoskeletal motor learning at scale](https://geneva.aitinkerers.org/talks/rsvp__HfRwdkJpVI)

MuscleMimic is an open-source, JAX-based framework for scalable motion imitation learning with physiologically realistic muscle-actuated humanoids. It provides validated musculoskeletal embodiments, including a 126-muscle upper-body model for bimanual manipulation and a 416-muscle full-body model for locomotion, together with motion-retargeting pipelines, pretrained checkpoints, datasets, and GPU-parallel training tools for learning human-like movement under full muscular control. By lowering the computational barrier to biomechanically accurate motor learning, MuscleMimic enables research at the intersection of embodied AI, reinforcement learning, biomechanics, neuroscience, robotics, and human movement science. Repo: https://github.com/amathislab/musclemimic Hugging Face playground: https://huggingface.co/spaces/amathislab/musclemimic_space

- Event context: AI Tinkerers Geneva Inaugural Meetup - May 2026 — 2026-05-13 — Geneva
- Public talk page: https://geneva.aitinkerers.org/talks/rsvp__HfRwdkJpVI

### [Porting Segment Anything: SAM2 in ONNX/C++, SAM3 in thin scripts](https://lausanne.aitinkerers.org/talks/rsvp_HLLk1mziQvk)

I built a portable interactive segmentation stack around Segment Anything: a C++/ONNX Runtime wrapper for SAM2 plus thin SAM3 image/video demo scripts that run on Windows CUDA or macOS Apple Silicon. In the demo I’ll show prompt-driven segmentation and video propagation, then pop the hood on how I split the model/runtime pieces so the same workflow runs outside research notebooks.

- Event context: AI Tinkerers Lausanne April 2026 Meetup — 2026-04-30 — Lausanne
- Public talk page: https://lausanne.aitinkerers.org/talks/rsvp_HLLk1mziQvk

### [MARSYS: Multi-Agent Workflows Without the Plumbing](https://lausanne.aitinkerers.org/talks/rsvp_eigQG2pH8qI)

MARSYS is an open-source Python framework for building multi-agent workflows. Define your agents and who talks to who -- the framework handles parallel execution, branch isolation, convergence, context management, and routing automatically. It works with 7+ LLM providers out of the box (OpenAI, Anthropic, Google, local models), ships with ready-to-use agents (browser, file operations, code executor, data analyst), and lets you fine-tune local models directly from execution traces. `pip install marsys` and you're running.

- Event context: AI Tinkerers Lausanne April 2026 Meetup — 2026-04-30 — Lausanne
- Public talk page: https://lausanne.aitinkerers.org/talks/rsvp_eigQG2pH8qI

### [Meet Reachy: Bringing AI Agents and Robots to Life](https://montreal.aitinkerers.org/talks/rsvp_W5uswbok9N0)

Reachy Mini is a voice-enabled and vision-capable AI robot that can see, speak, remember, reason through graph-based orchestration, use Databricks, and control a computer or external tools in real time.

- Event context: AI Tinkerers Montreal - March Demo Night — 2026-03-24 — Montreal
- Public talk page: https://montreal.aitinkerers.org/talks/rsvp_W5uswbok9N0

### [Your Brand Translator](https://paris.aitinkerers.org/talks/rsvp__5FOk0bFKFc)

A personal branch is a must for today's professionals and entrepreneurs. But these same people don't have time to do it themselves and services cost thousands. So we build an agent, - based on OpenClaw for easy interaction via WhatsApp, Telegram and Signal - with a ton of image and video editing tool: IG filters, automatic clipping, deep image generation, caption generation, video from image generation, video modifications, music generation, application of any HF-based model - and the ability to schedule the posts via buffer Share your expertise and experience effortlessly.

- Event context: High-Performance Local AI Development: Kick-off ThinkStation PGX — 2026-03-17 — Paris
- Public talk page: https://paris.aitinkerers.org/talks/rsvp__5FOk0bFKFc

### [Benchmarking Small Language Models Where It Actually Matters](https://paris.aitinkerers.org/talks/rsvp_ow7csxTS5J0)

Most SLM benchmarks answer the wrong question. They tell you how a model scores — not whether it works. This platform is designed for teams who care about real execution, not paper metrics. It lets you benchmark Small Language Models on Python and Polars code generation, under strictly controlled hardware conditions, with full visibility on performance, cost, and failure modes. Participants connect to the platform through a web interface and run benchmarks on large datasets and realistic workloads. The backend runs inside a Docker environment and can execute jobs directly on GPUs, whether locally or on dedicated infrastructure. Each run is configurable: quantization, decoding parameters, and runtime settings are part of the experiment, not hidden defaults. The focus on Polars is intentional. Most language models are very good at generating code for older, widely used libraries like pandas or NumPy. These libraries have been present in training data for years and appear in millions of examples online. Polars is different. It is a newer, high-performance data processing library designed for large-scale workloads, built around vectorized execution, query planning, and expression-based transformations. While it offers major performance advantages for large datasets, its programming model is significantly different from traditional Python data tools. As a result, many models struggle with it. They may generate code that looks correct but fails to run, produces incorrect results, or uses inefficient patterns that defeat the performance benefits of the library. This makes Polars an ideal stress test for evaluating whether a model truly understands modern data-processing workflows. Beyond model metrics (tokens/sec, VRAM usage, GPU utilization), the platform evaluates the generated code itself: Does it run? Does it produce the correct result? Is it efficient, or just “technically correct but slow”? To make progress measurable and engaging, the platform also supports a hackathon-style workflow: Real-time leaderboards Full attempt history per team and per benchmark Analytics dashboards highlighting where models systematically fail The goal is simple: give teams a new language to talk about model quality — not “good vs bad,” but correct, efficient, reliable, and production-ready. If you don’t measure this, you might end up shipping models that look good in demos… and quietly break in real workloads.

- Event context: High-Performance Local AI Development: Kick-off ThinkStation PGX — 2026-03-17 — Paris
- Public talk page: https://paris.aitinkerers.org/talks/rsvp_ow7csxTS5J0

### [Failing Fast with AI: Rapid Prototyping Using Google AI Studio](https://pereira.aitinkerers.org/talks/rsvp_BLcMVGVLlTs)

This demo explores a paradigm shift in product development: failing fast to learn faster. I’ll demonstrate how Google AI Studio can be used to rapidly prototype AI-powered applications, validate ideas, and surface potential product value—without investing significant time, money, or engineering resources upfront. The focus will be on hands-on experimentation, iteration cycles, and technical workflows rather than slides or theory.

- Event context: Cambio de paradigma AITINKERERS PEREIRA 2026 — 2026-02-26 — Pereira
- Public talk page: https://pereira.aitinkerers.org/talks/rsvp_BLcMVGVLlTs

### [Meta Modeling for drug discovery.](https://dc.aitinkerers.org/talks/rsvp_SBMb6DF9kMI)

I am training a meta model for ml based chemical binding prediction on open data. I already have about 1500 hundred fine tunes of binding predictions and the meta model will be used to predict the viability of future fine tunes. I am also investigating applying symmetry breaking to align binding symmetries with chemical point groups. This could tune the meta model to specific chemistries. If done this would be a new architecture. I currently have a simple web interface to show the results of my training runs and will be adapting it to output the results of the meta model. It is running locally but I may be able to have it open by the meeting. A lot of my work has been created with assistance from chatgpt and codex.

- Event context: AI Tinkerers - DC Metro Meetup - February 24th, 2026 — 2026-02-24 — DC
- Public talk page: https://dc.aitinkerers.org/talks/rsvp_SBMb6DF9kMI

### [The Geometry of Identity: High-Performance Matching with LightGlue](https://hong-kong.aitinkerers.org/talks/rsvp_CKcqvusIVsI)

In this deep dive, we move beyond the "black box" of face detection to dissect the underlying logic of neural feature matching. While traditional biometric systems often rely on global embeddings, this session explores the mechanics of sparse feature matching and how it can be used to quantify similarity with sub-millisecond precision. We will focus on the end-to-end pipeline: starting with classical keypoint extraction using SIFT, followed by state-of-the-art neural matching via LightGlue. We will explore how LightGlue’s transformer-based architecture utilises attention mechanisms to adaptively match SIFT keypoints. Furthermore, we will discuss how these complex models are optimised for real-time edge inference—a critical requirement for modern robotics and spatial computing. I will showcase two real-world implementation examples, including an interactive Google Colab notebook, so please bring your laptops.

- Event context: AI Tinkerers Hong Kong: Deep Dive Series - Deep Dive featuring Spatial Computing and Robotics — 2026-02-05 — Hong Kong
- Public talk page: https://hong-kong.aitinkerers.org/talks/rsvp_CKcqvusIVsI

### [Neural Probing LLMs for 'Immediate Inference'](https://montreal.aitinkerers.org/talks/rsvp_qy_wNEb75lc)

'Training' is an ongoing challenge but 'Inference' will be the dominant performance challenge of AI going forward, signalled by Groq acquisition by Nvidia. Autogeneration is slow and expensive, and it's now the dominant 'bottleneck'. 'Probing' or adding novel architectures onto LLMs (Heads) can accelerated inference by measuring the 'state' of an LLM side-stepping the requirement to generate tokens. I don't have a super fancy presentation or clean GitHub yet, it's just lab notes and demo. It actually works, this is serious, not just a toy.

- Event context: AI Tinkerers Montreal - January 2026 Meetup at Ateko — 2026-01-21 — Montreal
- Public talk page: https://montreal.aitinkerers.org/talks/rsvp_qy_wNEb75lc

### [vibe MLing - e2e finetunes on arbitrary domains with claude code via carefully synthesized data](https://cologne.aitinkerers.org/talks/rsvp_q79JPVgHEdM)

Inspired by huggingface's recent blog post on using Claude code to fine tune a model with an existing dataset (via their new CC skill), I wanted to see how much more of the e2e finetune process could be captured in SKILLs. Had a few days over Xmas break and 150 commits later I have 3 new SKILLs to share with the community to help (1) extract domain knowledge (2) iteratively generate and filter synthetic data and (3) run the finetune and eval it Have lots of challenges and learnings to share how I did it. I chose therapeutic coaching as my domain (but the SKILLs apply generally) and the resulting 14b finetuned model competes with human text based therapy

- Event context: AI Tinkerers Cologne #2: Let's Build. — 2026-01-21 — Cologne
- Public talk page: https://cologne.aitinkerers.org/talks/rsvp_q79JPVgHEdM

### [Multimodal SLMs: Qwen 2.5 and Air-Gapped Document Intelligence for Confidential Data](https://hong-kong.aitinkerers.org/talks/rsvp_wdu0jEPpJYA)

I'm helping Branches of Hope (a charity in Hong Kong dedicated to assisting refugees) effectively digitise their confidential refugee records into structured data. As a result, I've built a solution that can be air-gapped, on-prem utilising the open-source Qwen2.5-VL-7B model. Through this, I found that even SLMs are far more effective at OCR than traditional deep-learning based approaches (e.g. Tesseract). In fact they are so good that the guidance you provide in the prompt is vital. I've now updated to using the latest Qwen3-VL-8B-Instruct model, and I will also highlight the changes in power that the latest open-source models provide.

- Event context: AI Tinkerers Hong Kong Meetup - November 27th — 2025-11-27 — Hong Kong
- Public talk page: https://hong-kong.aitinkerers.org/talks/rsvp_wdu0jEPpJYA

### [Reactive Transformer - training next-gen stateful real-time language model with linear conversation cost scaling](https://poland.aitinkerers.org/talks/rsvp_jhPk-r6dnJU)

## Introduction My work is not another agent or LLM based project, but completely new conversational AI architecture. I created Reactive Language Models (RxLM), that are processing single interactions in real time (instead of all the chat history) with all the context moved to dedicated memory layers. It results in linear cost scaling, instead of quadratic - N times faster and cheaper than LLMs, where N is the number of messages in conversation. It could potentially replace LLMs in conversational tasks - answers are not only faster and cheaper, but have also better quality, because of pre-selection of the most important information for the dialog, instead of looking on all the history tokens - models have better results on each next conversation step, while for LLMs it's rather the opposite. While there were attempts to stateful transformers before (i.e. https://arxiv.org/abs/2209.07634), based on encoder-decoder transformer models, they used synchronous memory update in encoder before generating the answers and required previously generated answer to be included in input - that's why they aren't true real-time and have bigger delays than reference seq-to-seq models. Our Reactive Transformer is going further - it's processing only actual query in real-time (without any previous data) and is using asynchronous memory update - after generating all the response, so it's not influencing delay and is rather unnoticeable for the user. I published research paper about the architecture on arXiv and HuggingFace - https://arxiv.org/abs/2510.03561 / https://huggingface.co/papers/2510.03561. I have to design completely new training pipeline, that handle model's asynchronous nature and new stateful real-time processing, with supervised and reinforcement learning stages. We currently have four PoC models, trained on synthetic data with 12M, 26M, 100M and 160M parameters, and we started work on MVP models trained on real-world data with 270M, 1B and 4B params. In the demo I want to present the supervised training stages for Reactive Transformer ## Research details ### How are Reactive Language Models different from LLMs? - don't reinvent the wheel in language processing and reasoning - first architecture is named Reactive Transformer (RxT), because it's based on the Transformer architecture - in case of memory - it's not going back to RNN concepts, that used memory for state between the tokens (intra-sequence), but RxLM has memory between sequences/interactions (inter-sequence) - memory is accessed in decoder by memory cross-attention layers - similar to original encoder-decoder Transformer, but the source is not directly the encoder data - memory is updated after generating the answer for query - all the interaction (query and answer) is processed by encoder and connected with accumulated state by memory attention layers - that's why all the system is called Attention-Based Memory System (ABMS) - the N times lower computational cost results directly from the theory itself - we are just passing only the query to the model (`for token in model.interact(query)`), instead of the complex chat template with all the history - that's completely different from the direction taken by the rest of the field - they are going into longer context instead, what to be honest have no sense for conversational models from the economic reasons (accumulated costs). The LLMs answer quality is also becoming worse in longer conversations - even the biggest models are mixing information from different messages - for the RxT it's the opposite - on the other hand, real-time processing is much more natural for awareness. We, as a humans don't reprocess our life histories on every thought. RxLM memory is built intelligently on each step, taking and compressing the most important information. It also has no override concept - attention layers are combining states in the way, that old memories are slowly fading - the downside is, that they require more complex training - but we have designed and implemented most crucial steps and tested it in practice on PoC small scale models. Even the training is more complex, finally it's cheaper, mainly because of faster convergence in pre-training - i.e. in our experiments reference decoder-only model required 5 epochs of pre-training, while RxT only single epoch - we compared our RxT models with reference same-size classic decoder-only LLM, pre-trained on the same synthetic dataset and fine-tuned on the same dialog dataset. RxT reached about 2x lower perplexity in supervised dialog and also 2x higher BLEU in memory and dialog quality benchmark. I will publish more details and comparisons on our blog soon ## Training As the Reactive Transformer is a connected ensemble of cooperating models, its training process is more complicated, then standard LLM training. It requires more careful pre-training, fine-tuning and additional Memory Reinforcement Learning (MRL) stage. Our progressive learning process is designed as an extension to existing Transformer learning algorithms. It's divided into six separate stages: 1. Joint LM Pre-Training for encoder and decoder, on autoregressive language modeling and masked language modeling at once 2. Joint Components Interaction Supervised Fine-Tuning (SFT) 3. Memory Attention Self-Supervised Pre-Training 4. Supervised Memory-Aware Training 5. Memory Reinforcement Learning (MRL) for Short-Term Memory 6. Reinforcement Learning from Human Feedback for Reactive Models (RxRLHF) ## Connections to latest research in the field - they have similar language modeling components as LLMs, but the way how they are working is completely different and is taking the opposite direction - instead of passing all the chat history or some "memory" formatted by agent, it keeps all the context in dedicated Short-Term Memory - it doesn't contain text, but sets of embeddings on different abstraction level for each transformer layer. It's updated asynchronously after generating response - it's one time operation and is not influencing user's delays - they are made to fix the biggest overlooked LLMs problem - accumulated costs due to quadratic scaling. As I mentioned before, very long multi-turn conversations are disproportionately expensive (in example, in 100k tokens conversation with ~20 messages, I'm normally paying for about 1.5-2M tokens - with RxLM, it always be the cost of only those 100k tokens). - in case of LLM, we have chat templates, where all the previous messages from the conversation are accumulated - it's all passed to the model, that was fine-tuned for text completion in the chat template format. RxLMs are natively trained only for conversations and their "chat template" is limited to single message - "[Q] User's query... [A] Model's answer". Only the "[Q] Query... [A]" input sequence is passed to the model, that's generating the answer with access to context in memory by cross-attention layers, and is updating the memory after that - RxT is using KV-cache in the same way as LLMs, but it's always limited only to current interaction - then it's a lot smaller and is no longer a bottleneck for performance. RxT is more depending on pure computational costs, rather than memory costs. Additionally, it's using full pre-cache for memory cross-attention, that's leading to additional speed up - STM size is constant, single interaction (query + answer) is limited, so RxLMs have always the same (almost, single message could have different lengths) latency and cost, no matter how much messages are in conversation. As STM size is constant and limited, the model will be forgetting the information, but it's rather adaptive forgetting, than catastrophic - Reactive Transformer based only on Short-Term Memory is planned to handle fluid conversation of about 50-100 interactions. Overall context is still infinite, but model will not remember everything. That will be improved with our next architecture - Infinite Reactive Transformer, that's introducing Long-Term Memory, based on combination of RAG and attention-based memory - but it's still internal for the model, not the external agent functionality - as mentioned, it's not agentic framework - instead we are moving the agentic features from prompt-engineering to inside of the models - the sliding window attention is rather not compatible with memory design - it has no positional encoding and relations between memory slots could be not spatial, but rather time based - single window could include combined states from different time steps. That's why I was searching for efficient attention for memory, resulting in SQA discovery - additional memory cross-attention in each transformer block have some overhead, even when it's fully pre-cached. However, it could be noticeable only for first message in conversation. Next messages will be always faster, as it's always processing only single query and generating single answer. For complete fairness we can assume that the cost of a single interaction is O(NT) for LLM and O(2T) for RxLM, where N is the number of messages and T is the mean count of tokens in single interaction. - this stateful real-time processing is required for our upcoming Reactor AGI model, based on Infinite Chain-of-Thoughts - LLMs are not compatible. It's based on continuous processing in infinite reasoning loop, with memory fetch/update between reasoning steps - it's like internal monologue of two opposite symmetric sub-systems. In case of LLM, each next thought process will be slower and more expensive, and after some limited number of steps it will fill all the context. Reactive Transformer and Infinite Reactive Transformer were designed as Proof-of-Concept of the most crucial part of this architecture - the memory system, but they are enough revolutionary on their own, mainly for efficiency and natural processing - our models are using custom attention layers called Sparse Query Attention (SQA), that enable even 2-3x faster training. More info in dedicated research paper - https://arxiv.org/abs/2510.01817 ## Reactive Transformer (RxT) Presentation Plan: - quick introduction to Event-Driven AI, Reactive Language Models and Reactive Transformer - new architecture and it's algorithm flow - with detailed diagrams and code implementation in RxLM framework - introduction to RxT training - supervised stages, with all the steps, from initialization of the model to trainers, presented in the Jupyter Notebooks - differences from classic LLM pre-training - short introduction to Memory Reinforcement Learning and recommended parameters for this training stage (if there will be a time) - after that short demo, everyone attending will be able to train their own real-time Reactive Language Model with Short-Term Memory using our RxLM framework and HuggingFace Hub integration, with our prepared experimental datasets ## More content: Webpage: https://rxai.dev HuggingFace Hub: https://huggingface.co/ReactiveAI GitHub profile: https://github.com/RxAI-dev RxLM framework: https://github.com/RxAI-dev/RxLM All the implementation is currently available in RxLM library - https://github.com/RxAI-dev/rxlm, but the documentation is still in progress - I will update it soon

- Event context: AI Tinkerers Poland #6 - Meetup in Warsaw (26th November) — 2025-11-26 — Poland
- Public talk page: https://poland.aitinkerers.org/talks/rsvp_jhPk-r6dnJU

### [Teaching small language models a thing or two](https://amsterdam.aitinkerers.org/talks/rsvp_5y9_LDXh3rQ)

I will be presenting our efforts in finetuning a range of small language models (SLMs) for both fun and useful use-cases. I shall go through the pipeline of how to finetune SLMs with limited data and why this might be the future.

- Event context: AI Tinkerers Amsterdam – November 2025 Edition — 2025-11-11 — Amsterdam
- Public talk page: https://amsterdam.aitinkerers.org/talks/rsvp_5y9_LDXh3rQ

### [JetBrains Long Code Arena](https://toronto.aitinkerers.org/talks/rsvp_85jBYLgz6Bc)

We are contributing to an open-source project by JetBrains Research called Long Code Arena (LCA). LCA consists of 6 benchmarks that evaluate how AI models perform in evaluating different aspects of a developer’s entire project. The two benchmarks we have been working on include the project-level code completion and library-based code generation. The project-level code completion uses the full project as context to generate the next line of code in a file. The library-based code generation tests the model’s ability to generate appropriate code relying on library methods. We evaluated several models and measured their performance using key benchmark-specific metrics. More specifically, we employ various techniques to enhance model performance. Some strategies included how we provide the prompts and additional context. Additionally, we contributed more metrics, such as syntax matching and n-gram matching, to assess the model output quality more effectively. Our project is crucial because it enables us to experiment with various context collection techniques based on the source datasets provided by JetBrains.

- Event context: AI Tinkerers Toronto - November 2025 Meetup at Shopify! — 2025-11-10 — Toronto
- Public talk page: https://toronto.aitinkerers.org/talks/rsvp_85jBYLgz6Bc

### [Live Full-Stack PDF Insights Pipeline: Flask + AWS S3 + React UI](https://nyc.aitinkerers.org/talks/rsvp_u9T-10v0GWo)

I’ll walk through the end-to-end architecture of a full-stack web application that automates product insights and user recommendations using AI. The app uses a React front-end with a Flask backend API to process data pulled from AWS S3 storage, combined with embeddings and basic NLP to make personalized suggestions. This demo will focus on the technical layers, including React component rendering, Python data pipelines, secure REST API routes, and cloud orchestration via AWS.

- Event context: Auth0 x AI Tinkerers: Fall Social Demo Night 🍁 ft. Hex — 2025-11-06 — New York City
- Public talk page: https://nyc.aitinkerers.org/talks/rsvp_u9T-10v0GWo

### [LLMs for retrieval and recommendation](https://toronto.aitinkerers.org/talks/rsvp_fnoZbMMW_ao)

I will show how to use vLLM and an openweight model to make a simple recommendation engine and use guided decoding to limit the output of the llm to the allowed items only. No finetuning needed and it will work on google colab so basically no hardware needed either. the code i shared will be a bit more, that is just a draft.

- Event context: AI Tinkerers Toronto - October 2025 Meetup at CIBC | Simplii — 2025-10-30 — Toronto
- Public talk page: https://toronto.aitinkerers.org/talks/rsvp_fnoZbMMW_ao

### [CantoneseLLM](https://hong-kong.aitinkerers.org/talks/rsvp_rniZKOvRbBA)

This talk addresses the critical challenge faced by leading Large Language Models (LLMs) when processing the highly dynamic, slang-infused, and diverse linguistic landscape of Hong Kong Cantonese. Despite being a highly utilized language, Cantonese remains a "low-resource" language in the global AI training ecosystem, leading to significant failure and reduced performance for general-purpose LLMs (like those from major tech companies). We will present **CantoneseLLM**, an LLM developed by **Votee** specifically trained to tackle this complexity. CantoneseLLM is designed to handle the massive target distribution increase caused by intense Cantonese slang input, which typically causes external models to fail. The presentation will cover: 1. **The Cantonese Data Crisis:** Why traditional LLM training fails when faced with localized Hong Kong language nuances. 2. **Community Empowerment:** The role of the **"hon9kon0ize"** community (a dedicated Cantonese AI group) in curating and pushing forward high-quality, local datasets necessary for training specialized models. 3. **The Specialized Solution:** An in-depth look at **Votee's CantoneseLLM**—how it was built, its unique training methodologies for low-resource languages, and its performance benchmarks. 4. **Comparative Analysis with the "HK Canto Eval" Benchmark:** To measure what truly matters, the **hon9kon9ize** community and **Votee** co-developed the **"HK Canto Eval"** benchmark. We will first present how leading SOTA models like Ernie 4.5 perform on this culturally-specific suite. We then demonstrate how **CantoneseLLM** achieves highly comparable results on these demanding local tasks, proving a specialized model can match global giants when tested on true linguistic and cultural fluency. This session serves as a crucial case study, showcasing how dedicated, localized effort can successfully tackle the low-resource language problem and boost the Cantonese AI community.

- Event context: AI Tinkerers - Hong Kong Meetup (August) - Meetup with Baidu PaddlePaddle — 2025-08-22 — Hong Kong
- Public talk page: https://hong-kong.aitinkerers.org/talks/rsvp_rniZKOvRbBA

### [Contract Analysis Pipeline: Extract, Flag, and Review Legal Docs Fast](https://dallas-fort-worth.aitinkerers.org/talks/rsvp_zTMgjWc8PLk)

I will demo a working Contract Analysis Pipeline that ingests sample legal contracts and automatically extracts key terms (e.g., parties, amounts, deadlines), flags risky or ambiguous clauses (like indemnity or termination), and highlights non-standard language based on predefined templates. The pipeline is designed to reduce manual legal review time from hours to minutes. The live demo will show: • Clause-level parsing using a Hugging Face model • How I evaluate risk using prompt-like logic and pattern matching • Streamlit UI displaying before/after annotated contracts Challenges with clause ambiguity and misclassification and how I addressed them.

- Event context: AI Tinkerers – Dallas-Fort Worth Inaugural Meetup · 31 July 2025 — 2025-07-31 — Dallas Fort Worth
- Public talk page: https://dallas-fort-worth.aitinkerers.org/talks/rsvp_zTMgjWc8PLk

## Related Technologies

- [Python](https://aitinkerers.org/technologies/python) ([Markdown](https://aitinkerers.org/technologies/python.md)) — 664 public demos
- [PyTorch](https://aitinkerers.org/technologies/pytorch) ([Markdown](https://aitinkerers.org/technologies/pytorch.md)) — 273 public demos
- [Google Colab](https://aitinkerers.org/technologies/google-colab) ([Markdown](https://aitinkerers.org/technologies/google-colab.md)) — 12 public demos
- [OpenAI API](https://aitinkerers.org/technologies/openai-api) ([Markdown](https://aitinkerers.org/technologies/openai-api.md)) — 520 public demos
- [vLLM](https://aitinkerers.org/technologies/vllm) ([Markdown](https://aitinkerers.org/technologies/vllm.md)) — 33 public demos
- [GPT-4](https://aitinkerers.org/technologies/gpt-4) ([Markdown](https://aitinkerers.org/technologies/gpt-4.md)) — 529 public demos
- [Transformers](https://aitinkerers.org/technologies/transformers) ([Markdown](https://aitinkerers.org/technologies/transformers.md)) — 148 public demos
- [Anthropic API](https://aitinkerers.org/technologies/anthropic-api) ([Markdown](https://aitinkerers.org/technologies/anthropic-api.md)) — 66 public demos
- [Claude](https://aitinkerers.org/technologies/claude) ([Markdown](https://aitinkerers.org/technologies/claude.md)) — 174 public demos
- [Data](https://aitinkerers.org/technologies/data) ([Markdown](https://aitinkerers.org/technologies/data.md)) — 8 public demos
- [Docker](https://aitinkerers.org/technologies/docker) ([Markdown](https://aitinkerers.org/technologies/docker.md)) — 147 public demos
- [FastAPI](https://aitinkerers.org/technologies/fastapi) ([Markdown](https://aitinkerers.org/technologies/fastapi.md)) — 181 public demos
- [Firebase](https://aitinkerers.org/technologies/firebase) ([Markdown](https://aitinkerers.org/technologies/firebase.md)) — 23 public demos
- [GitHub](https://aitinkerers.org/technologies/github) ([Markdown](https://aitinkerers.org/technologies/github.md)) — 74 public demos
- [Google Cloud Platform](https://aitinkerers.org/technologies/google-cloud-platform) ([Markdown](https://aitinkerers.org/technologies/google-cloud-platform.md)) — 25 public demos
- [HuggingFace](https://aitinkerers.org/technologies/huggingface) ([Markdown](https://aitinkerers.org/technologies/huggingface.md)) — 7 public demos
- [LangChain](https://aitinkerers.org/technologies/langchain) ([Markdown](https://aitinkerers.org/technologies/langchain.md)) — 446 public demos
- [NVIDIA](https://aitinkerers.org/technologies/nvidia) ([Markdown](https://aitinkerers.org/technologies/nvidia.md)) — 7 public demos

## More Results

- Next: https://aitinkerers.org/technologies/hugging-face.md?page=2