monatis

I'm developing ggmlc, an ML compiler that automatically lowers any PyTorch/JAX/Flax/Keras model to high level GGML execution. Using that, I compiled laya to GGUF and developed a single executable. Laya is an open-source Jev-alternative system-1 model. The executable binary can be used for one-shot launch from the command line, with JSON-formatted lines over stdin/stdout communication (for agents and programmatic integrations), and through an http API. It also comes with a built-in web UI.

You can learn more and download the pre-built executables from the ggmlc repo and download the GGUF files on HF: I read a request for Jev-compatible endpoint, /v1/sysstemone, and I'll include it in the next release. If you have any other requests and/or feedback, please feel free to reach out to me in ggmlc issues.

isanagent is opensource! I implemented an always-on and autonomous ML engineer that works 24/7 to conduct research, generate datasets, train models, learn and evolve. Works on Colab, local GPU or over SSH. Zero infra needed!

Whether you need to fine-tune a model, generate a synthetic dataset, apply a new method to your problem, or make your models run faster, it handles the execution and gives you actual deliverables: working scripts, trained models, and clean Jupyter notebooks showing exactly what worked and what didn't. You don't even need a heavy compute setup to run it. It works on local GPUs, over SSH, or even completely free on Google Colab with zero infrastructure required!

Using Colab, isanagent achieved 3x speedup for Turboquant in TPUs

Yeah this is one possible way to generate grounded an"responses" in Afterimage. To accomplish context augmentation when generating a response, it allows to use different RAG strategies where retriever may be chosen for the specific use case at hand. This is where composability comes into play.

We kept running into the same exact bottleneck with fine-tuning and evals: You have the source documents, and you have the base model, but you usually don’t have the actual conversations.

If you’re working with internal docs, regulatory text, or technical manuals, there’s plenty of material but zero multi-turn chat logs. And flattening this into standard instruction/response pairs creates models that sound like templates, failing to capture how users actually ask for clarification or push back.

So we open-sourced a small, opinionated library called AfterImage.

It generates synthetic multi-turn conversations grounded in a corpus you provide. The architecture is straightforward: - A simulated user ("Correspondent") with optional persona variation - A simulated assistant ("Respondent") - Both strictly grounded via sampled source material - Outputs directly to JSONL for your SFT (Supervised Fine-Tuning) / eval pipelines

*Why build this?* The narrow bet here is that multi-turn dialogue is its own distinct data problem. There are already great general synthetic data tools (distilabel, synthetic-data-kit). We aren't competing with them. AfterImage prioritizes composable design where generation can be customized with callbacks. For example, you can connect it to various data sources such as local files or Qdrant collections, or you can choose retriever strategies for RAG or aggregation methods for composite evaluation.

*A few honest caveats:* - We don’t have a strong published benchmark yet (semantic similarity only so far). - Quality noticeably degrades/loops as conversations get too long (>5+ turns). Luckily, one-to-three turns is more than enough for most SFT cases.

I implemented CLIP inference in plain C/C++ with no extra dependencies thanks to the great work in GGML that powers llama.cpp. It can work with models from both OpenAI and LAION. It also supports 4-bit quantization for extremely constrained devices, 4-bit CLIP-base is only ~85 MB!

I'm also happy to hear that a company is thinking of adopting it for their project only a few hours after I announced the repo.

Check it out and feel free to reach out to me for any suggestions or give it a star

Similarity search becomes a part of many technical stacks. Qdrant can be deployed as a service for fast, lightweight and filterable vector search. It's opensource, and you can also get up and running instantly and for free wit the cloud offering. You can try here https://qdrant.tech

Great work, congrats. You might be already familiar with Qdrant, but feel free to reach out to me if you'd like to get help testing or discuss anything around it.

Some loss functions such as ArcFace loss and CosFace loss enforce the encoder model to organize their latent space in such a way that categories are placed with an angular margin from one another. Thus the model implicitly learns a continuous distance function.

Fun fact, one of the examples in Quaterion is for similar cars search.

If you find this topic and want to discover more, we collected a bunch of resources that might be helpful. https://github.com/qdrant/awesome-metric-learning

The main idea is to train a deep learning model to encode a high-dimensional sample to a low-dimensional vector in a latent space. Then it can be used in various downstream tasks such as KNN applications, semantic search, multimodal retrieval, recommendation systems, anomaly detection etc. It's not limited to the image domain --it can be also audios, texts, videos, or more specific entities such as authors, soccer players, songs etc. The size of the dataset can be thought of being similar to other deep learning methods, but you can make a choice among various similarity learning methods based on the size of your dataset or according to whether it's labeled or not. A common approach is (1) to train a base model by using a self-supervised method with a bulk amount of unlabeled data and (2) to finetune it on a more specific domain or task with a smaller labeled dataset. If you can start with a pretrained model such as ResNet or BERT, you can skip the first step.

There's study here: http://cs230.stanford.edu/projects_spring_2021/reports/57.pd...

Basically, you can collect text from different authors, then you can use authors names as labels to train a similarity learning with it. My suggestion would be finetune a Transformer model with a specific head and an ArcFace loss.

I'm one of the authors of Quaterion and also a contributor of TF Similarity. First of all, Quaterion is based on PyTorch. From a more technical perspective, TF Similarity is currently stronger on the self-supervised methods for images and lacks some more generic losses while Quaterion puts a bigger emphasis on finetuning models from any domain efficiently for practical purposes. For example, Quaterion has a intermediate caching mechanism that accelerates finetuning considerably. Overall, They both do a good job for their own use cases.