Projects

### Overview: OpenRCA is a benchmark designed to evaluate Large Language Models (LLMs) in their ability to locate the root cause of software failures. It focuses on assessing models' performance in analyzing large volumes of telemetry data, including KPI time series, dependency trace graphs, and semi-structured log text. The benchmark is particularly relevant for understanding how models can effectively identify and explain complex system issues. ### Key Features: - **Benchmarking**: Measures LLMs' root cause analysis capabilities in software failures. - **Data Integration**: Utilizes telemetry data from various systems (Telecom, Bank, Market) to simulate real-world scenarios. - **Scalability**: Evaluates models' performance in handling extensive telemetry data without being bogged down by context processing. - **Baseline**: Introduces RCA-agent, a Python-based baseline model, to provide a comparison point. ### Tech Stack: - **Python**: The primary programming language used for implementing the benchmark and baseline model. ### Why It Matters: - **Benchmarking Accuracy**: Provides a standardized way to measure and compare the root cause analysis capabilities of different LLMs. - **Real-World Simulations**: Simulates various system environments to evaluate models' effectiveness in identifying root causes. - **Scalability Testing**: Ensures models can handle large volumes of telemetry data efficiently, without being overwhelmed by context processing. ### Repository: - **GitHub Repository**: [microsoft/OpenRCA](https://github.com/microsoft/OpenRCA) - **GitHub Stars**: 443 - **Description**: An open-source benchmark for

### Overview: HORUS is a fast, real-time distributed middleware system designed for systems where latency, determinism, and safety are crucial. It uses shared-memory ring buffers and lock-free synchronization to achieve sub-200ns IPC, making it an ideal choice for robotics, industrial automation, autonomous vehicles, trading systems, game engines, and more. ### Key Features: - **Fast IPC**: HORUS achieves sub-200ns IPC, making it highly suitable for real-time applications. - **Shared-Buffer Architecture**: Uses ring buffers for efficient data sharing. - **Lock-Free Synchronization**: Ensures deterministic behavior and high performance. - **Cross-Platform**: Works on any system where real-time and safety are important. - **Cross-Language**: Supports Rust, Python, and C++ APIs for seamless integration. ### Tech Stack: - **Rust**: The primary language for the core implementation. - **Python**: Provides an API for Python developers. - **C++**: Offers a C++ API for C++ developers. ### Why It Matters: - **Real-Time Performance**: HORUS excels in real-time applications where latency and determinism are critical. - **Safety and Reliability**: Ensures safety and reliability in systems where safety and reliability are paramount. - **Versatility**: Works across various industries including robotics, industrial automation, autonomous vehicles, trading systems, and more. ### GitHub Stats: - **GitHub Stars**: 445 - **Latest Release**: 0.4.1 - **CI Status**: [![CI](https://github.com

Overview: Mentals AI is a tool designed for creating and operating AI agents that feature loops, memory, and various tools, all through Markdown files with a .gen extension. It eliminates the need to write scaffolding code in Python or any other language, focusing solely on the logic of the agent. Key features: - Agent Executor: Operates through a recursive loop. - Memory: Stores and retrieves information. - Tools: Various functionalities provided through the agent's logic. Tech stack: C++ Why it matters: Mentals AI redefines foundational frameworks for future AI applications, offering a more intuitive and straightforward approach to creating AI agents without the complexity of traditional frameworks. Repository: turing-machines/mentals-ai GitHub stars: 445 GitHub description: No code AI agents

### Overview: ocaml-torch provides OCaml bindings for PyTorch, enabling NumPy-like tensor computations with GPU acceleration and automatic differentiation. This library automates the generation of bindings using the PyTorch C++ API, making it easy to integrate PyTorch's functionalities into OCaml projects. ### Key Features: - OCaml bindings for PyTorch tensor library - GPU acceleration for efficient computations - Automatic differentiation for gradient-based learning - Automatic generation of bindings using PyTorch C++ API ### Tech Stack: - OCaml - PyTorch C++ API ### Why It Matters: ocaml-torch simplifies the integration of PyTorch's capabilities into OCaml projects, making it easier to leverage PyTorch's advanced features such as GPU acceleration and automatic differentiation. This library is particularly useful for researchers and developers working on OCaml projects that require machine learning capabilities. ### Repository: Repository: LaurentMazare/ocaml-torch GitHub Stars: 444 ### Opam Installation: The opam package can be installed using the following command: ```bash opam install torch ``` ### Build a Simple Example: To build a first PyTorch program, create a file `example.ml` with the following content: ```ocaml open Torch let () = let tensor = Tensor.randn [ 4; 2 ] in Tensor.print tensor ``` Then create a `dune` file with the following content: ```ocaml (executables (names example) (

Overview: Ocular is an AI-powered search and chat platform designed for organizations, offering a Google-like interface and enterprise-specific features like app marketplaces and custom connectors. It simplifies the setup of internal search and generative AI solutions without the need for extensive architecture. Key features: - Google-like search interface - App marketplaces for easy integration - Custom connectors for accessing proprietary data - Customizable modular infrastructure - Governance engine for role-based access control and audit logs Tech stack: TypeScript Why it matters: Ocular provides a user-friendly and efficient way to integrate AI and generative search into enterprise environments, making it easier for businesses to manage and utilize advanced AI technologies without the complexity of custom development.

### Overview: Omini Kontext is an inference and training framework for multiple image input in Flux Kontext dev, designed for developers. ### Key features: - Nodes and patches for ComfyUI compatible with Nunchaku extension - Supports Qwen-Image-Edit spatial character insertion model - Compatible with Flux Kontext model for reference-based image edits ### Tech stack: Jupyter Notebook ### Why it matters: Omini Kontext is a framework built around Flux Kontext, enabling developers to experiment with reference-based image edits using 3D RoPE embeddings. This approach is inspired by the OminiControl project, aiming to create a more robust and intuitive reference-based image generation model.

### Overview: This repository is a curated list of awesome Distributed Deep Learning resources, including frameworks, blogs, papers, and books. ### Key features: - MXNet: A lightweight, portable, flexible distributed/mobile deep learning framework. - go-mxnet-predictor: A Go binding for MXNet for inference. - Deeplearning4j: A distributed deep learning platform for Java, Clojure, Scala. - DMTK: A distributed machine learning framework by Microsoft. - Elephas: An extension of Keras for distributed deep learning with Spark. - Horovod: A distributed training framework for TensorFlow. ### Tech stack: Python, R, Julia, Go, Javascript, Java, Clojure, Scala, Python, R, Julia, Go, Javascript, Java, Clojure, Scala. ### Why it matters: This repository provides a comprehensive collection of resources for anyone interested in distributed deep learning, including frameworks, blogs, papers, and books, making it an invaluable resource for developers looking to enhance their skills in this field.

### Overview: This project combines the power of [llama.cpp](https://github.com/ggml-org/llama.cpp) and [Chroma](https://github.com/chroma-core/chroma) to build a Conversation-aware Chatbot that utilizes RAG (Retrieval-augmented generation) for providing answers based on contextual information extracted from Markdown files. ### Key features: - RAG (Retrieval-augmented generation) ChatBot - Markdown file-based input - Context-aware responses - Memory index for chat history - Open-source LLM model integration - Embedding model setup - Response synthesis strategy ### Tech stack: Python ### Why it matters: This project offers a conversational chatbot experience similar to that of ChatGPT, utilizing the power of LLMs and Chroma for context-aware responses, making it useful for various applications requiring detailed and contextually relevant answers.

Overview: Collaborative Diffusion is a method for generating and editing multi-modal face images, showcasing promising results in both face generation and editing. Key features: - Supports multi-modal face generation and editing. - Uses pre-trained uni-modal diffusion models for guided face generation and editing. - Implements a dynamic diffuser that selectively enhances or suppresses contributions from different modalities. Tech stack: Python Why it matters: This innovative approach leverages pre-trained models to achieve high-quality face generation and editing, making it a significant advancement in the field of computer vision. Repository: ziqihuangg/Collaborative-Diffusion Primary language: Python GitHub stars: 444 GitHub description: [CVPR 2023] Collaborative Diffusion

Overview: Sagify simplifies the management of machine learning workflows on AWS SageMaker, focusing on ease of use and integration with open-source and proprietary models. Key features: - Simplified interface for AWS SageMaker management - Modular architecture with an LLM Gateway for unified model access - Support for various LLMs through a simple API - Open-source and proprietary model support for chat completions and image creation Tech stack: Python Why it matters: Sagify makes it easy for developers to focus on building ML models rather than managing infrastructure, making it accessible and user-friendly.

Overview: This project is a PyTorch implementation of Fast-SCNN, a fast semantic segmentation network from the paper "Fast-SCNN: Fast Semantic Segmentation Network" by Rudra PK Poudel and Stephan Liwicki. Key features: - Fast-SCNN implementation using PyTorch - Supports cityscapes dataset for training and evaluation - Provides evaluation metrics such as mIoU and pixAcc Tech stack: Python Why it matters: This project offers a practical solution for fast semantic segmentation tasks, making it useful for applications requiring real-time performance in image segmentation tasks. Repository: Tramac/Fast-SCNN-pytorch Primary language: Python GitHub stars: 443 GitHub description: A PyTorch Implementation of Fast-SCNN: Fast Semantic Segmentation Network

### Overview: Triplet Attention is an efficient attention mechanism designed for convolutional neural networks, leveraging the ability to capture dependencies across dimensions. This method introduces a novel approach to computing attention weights, significantly reducing computational overhead while maintaining performance on various computer vision tasks. ### Key Features: 1. **Triplet Attention Module**: A lightweight and effective attention mechanism that computes attention weights by rotating input tensors and residual transformations, capturing cross-dimension interactions. 2. **Efficiency**: Designed to be easily integrated into existing backbone networks, making it highly versatile and efficient. 3. **Versatility**: Applied to various tasks including image classification on ImageNet-1k and object detection on MSCOCO and PASCAL VOC datasets. 4. **Visualization**: Provides insights into performance through visual inspection of GradCAM and GradCAM++ results, highlighting the importance of dimension-dependent attention. ### Tech Stack: PyTorch ### Why It Matters: Triplet Attention offers a simple yet effective solution for attention mechanisms, particularly in scenarios where computational efficiency is crucial. Its ability to handle dependencies across dimensions enhances the performance of neural networks, making it a valuable addition to the toolkit of computer vision practitioners.

### Overview: This project is a PyTorch implementation of the YOLOv2 object detection model, designed to enhance productivity and ease of deployment. It utilizes PyTorch as the framework and ONNX for converting models into Caffe 2 format for engineering deployment. The project includes features such as flexible configuration, monitoring with TensorBoard, parallel model training, NoSQL database for evaluation results, time-based output, checkpoint management, NaN debug, and a unified data cache system. ### Key Features: - **Flexible Configuration Design**: Configurable via command line arguments or a configuration file. - **Monitoring with TensorBoard**: Track loss values and debugging images. - **Parallel Model Training**: Saves models in different directories for simultaneous training. - **NoSQL Database for Evaluation Results**: Stores multiple dimensions of information. - **Time-Based Output**: Saves running information periodically. - **Checkpoint Management**: Preserves several latest checkpoint files. - **NaN Debug**: Exports the running environment and model when NaN loss is detected. - **Unified Data Cache**: Converts various dataset into a unified data cache. - **Arbitrarily Replaceable Model Plugin**: Easy replacement of the main deep neural network. - **Extendable Data Preprocess Plugin**: Processes original images and labels with multiple plugins. ### Tech Stack: - **Framework**: PyTorch - **Backend**: ONNX ### Why It Matters: This project provides a practical and efficient solution for implementing and deploying YOLOv2 models, making it easier for developers to integrate and utilize the model in their projects. The features and design

Overview: SDFX is an advanced no-code platform designed to build and share AI apps with a beautiful user interface, offering a seamless integration with ComfyUI workflows. Key features: - Seamless integration with ComfyUI workflows - Creation of straightforward user interfaces for intricate workflows - Richly enriched JSON structure for workflow descriptions - Customizable node bookmarks and advanced graph search - Fast UI instantiation and high-level components - Native Custom Nodes Manager - Export and share apps and templates - Advanced layer-based image and mask editor - Advanced checkpoint picker and gallery - Advanced input image picker - Modern frontend stack using Vite.js and TypeScript Tech stack: TypeScript Why it matters: SDFX simplifies the creation of AI applications by providing a user-friendly interface while maintaining compatibility with existing ComfyUI workflows, making it a valuable tool for developers looking to enhance their projects with modern UI design.

### Overview: WaveDiff is an official PyTorch implementation of the paper "Wavelet Diffusion Models are Fast and Scalable Image Generators" presented at CVPR 2023. This repository offers a novel wavelet-based diffusion scheme that accelerates the sampling process while maintaining high-quality image generation. The model is trained on CelebA-HQ, CIFAR-10, LSUN-Church, and STL-10 datasets and achieves state-of-the-art performance in terms of training and inference speed. ### Key Features: - **Wavelet Diffusion Scheme**: Uses low-and-high frequency components of wavelet subbands from both image and feature levels to accelerate the sampling process. - **Adaptive Sampling**: The scheme is designed to be adaptive, improving the generation quality while maintaining efficiency. - **State-of-the-Art Performance**: Demonstrates superior training and inference speed on various datasets compared to existing methods. ### Tech Stack: - Python 3.7.13 - PyTorch 1.10.0 - Pytorch Wavelets Library ### Why It Matters: WaveDiff offers significant improvements in training and inference speed, making it a valuable tool for real-time and high-fidelity image generation. Its ability to maintain high quality while accelerating performance makes it a promising advancement in the field of diffusion models. ### GitHub Stars: 442 ### Repository: - Repository: VinAIResearch/WaveDiff - Primary Language: Python - GitHub Stars: 442 ### Installation: - **Recommended Method**: Create a `conda

Overview: DisCoPy is a Python toolkit designed for computing with string diagrams, offering a variety of functionalities including abstract base classes, a `Diagram` data structure, formal grammars, and implementations of categorical quantum mechanics and lambda terms. Key features: - Abstract base classes for `Category`, `MonoidalCategory`, and subclasses. - A `Diagram` data structure for string diagrams in any premonoidal category. - Interfaces for formal grammars including context-free, categorial, pregroup, and dependency grammars. - Implementations of categorical quantum mechanics with tools like tket and PyZX. - `Drawing` and `Term` data structures for labeled graphs and lambda terms. - `Hypergraph` and `Symmetric`, `Traced`, `Compact`, and `Markov` categories for string diagrams. - `CombinantorialMap` for compact categories and restrictions. - `Stream` data structure for monoidal streams. - The `Int`-construction for geometry of interaction. Tech stack: Python Why it matters: DisCoPy simplifies the computation and analysis of string diagrams, making it useful for researchers and practitioners in various fields such as quantum computing, category theory, and natural language processing. Repository: discopy/discopy Primary language: Python GitHub stars: 442 GitHub description: The Python toolkit for computing with string diagrams.

Overview: This repository contains links to various models, datasets, and tools for Ukrainian speech recognition and synthesis. Key features: - Speech-to-Text models with 600M and 300M parameters - Text-to-Speech models with 1B and 1024 parameters - Datasets and leaderboards on Hugging Face - Implementations of models like wav2vec2, HuBERT, Citrinet, ContextNet, FastConformer, Squeezeformer, Conformer-CTC, and Whisper Tech stack: Python Why it matters: This repository provides a comprehensive collection of resources for Ukrainian speech recognition and synthesis, making it valuable for developers and researchers in the field.

Overview: tsflex is a toolkit designed for flexible time series processing and feature extraction, making it efficient and adaptable to various sequence data types. Key features: - Feature extraction - Time series processing Tech stack: Python Why it matters: tsflex simplifies the process of extracting and processing time series data, making it a valuable tool for researchers and developers working with sequence data.

### Overview: This repository contains an extensive list of papers and projects related to monocular 3D detection, focusing on advancements in object detection using monocular cameras. The papers cover various techniques such as depth adaptation, masked autoencoders, and multi-view consistency, aiming to improve the accuracy and robustness of 3D object detection in monocular settings. ### Key Features: - **Paper List**: A comprehensive collection of papers on monocular 3D detection, categorized by year. - **KITTI Results**: Performance metrics and results from the KITTI dataset, highlighting the effectiveness of the methods. - **Techniques**: Includes methods like depth-aware masked autoencoders, pseudo-labeling, and multi-view consistency, demonstrating the evolution of monocular 3D detection techniques. ### Tech Stack: - **PyTorch**: Used for implementing and testing the models and algorithms. ### Why It Matters: This repository serves as a valuable resource for researchers and developers interested in improving the accuracy and robustness of monocular 3D detection. It provides a curated list of cutting-edge papers and projects, making it easier to stay updated with the latest advancements in the field. ### Repository: - **Repository Name**: BigTeacher-777/Awesome-Monocular-3D-Detection - **GitHub Stars**: 441 - **GitHub Description**: Awesome Monocular 3D detection - **Primary Language**: Unknown - **GitHub Description**: This repository contains an extensive list of papers and projects related to monocular 3D detection, focusing on advancements in

### Overview: This repository contains the official code for the CVPR 2022 paper "Dataset Distillation by Matching Training Trajectories". The project aims to learn a small number of synthetic images that a model trained on this set alone will have similar test performance as a model trained on the full real dataset. ### Key features: - Training expert trajectories using ConvNet models. - Distilling synthetic data from real dataset trajectories. - Optimizing fake images to induce similar network training dynamics as the full, real dataset. - Generating class-based textures for continuous training trajectories. - Applying textures to areas requiring specific properties, such as clothing patterns. ### Tech stack: Python ### Why it matters: This method helps in reducing the size of the dataset while maintaining the same performance as a larger dataset, making it useful for resource-constrained environments and improving the efficiency of model training.