Projects

Overview: This project is a pipeline designed to generate long videos based on text prompts, utilizing Python as the primary language and showcasing impressive results with a gallery of examples. Key features: The pipeline includes a template for obtaining segmented fragments and complex descriptions, as well as two backbone models: I2VGen-XL and SVD for generating long videos. Tech stack: Python Why it matters: This project offers a powerful tool for generating long videos from textual prompts, showcasing impressive results and facilitating easy implementation through Python and the provided templates.

### Overview: LM Stud is a Windows desktop program designed for running and orchestrating local language models without the need for a browser or cloud dependency. It supports GGUF models, APIs, and tools, offering a minimal GUI interface for efficient operation. ### Key Features: - **Slot System**: Configurable slots for local models, API models, tool models, and API server routing. - **Multiple Loaded Models**: Multiple models can be loaded at the same time and generate in parallel. - **Shared Local Weights**: Slots using the same local model share weights, reducing memory usage. - **llama.cpp b9222**: Includes recent upstream work, including MTP support. - **KV Cache Type Selection**: Pick cache types including Q4_0, Q5_0, and Q8_0. - **Multiple API Formats**: Parses OpenAI, Chat Completions, Anthropic, Ollama, and Gemini-style responses. - **Streaming Tool Output**: Some tools can stream their output into the chat/API flow instead of waiting in silence. - **Dialectic Relay**: Allows 2 local slots to talk to each other, optionally with different models and system prompts. ### Tech Stack: C# ### Why It Matters: LM Stud is a minimal GUI interface for `llama.cpp`, `whisper.cpp`, tools, API models, and a classic Windows Forms interface for minimal GUI bloat. It runs on Windows 7 and later, ensuring perfectly good old machines can hallucinate too.

### Overview: Virtual Try-On FashionGenAI is an AI-powered tool that enables users to visualize themselves in different outfits based on their images and text prompts. Utilizing Stable Diffusion Inpainting and U2Net segmentation, it isolates clothing parts and generates customized outfits. ### Key Features: - **Stable Diffusion Inpainting**: Fills in the clothing region with realistic details. - **U2Net Segmentation**: Precise segmentation of clothing parts (upper or lower body). - **Customizable Prompts**: Allows for various clothing styles and colors. - **Background Removal**: Optional feature to remove the background. ### Tech Stack: - Python ### Why It Matters: This project is crucial for individuals looking to try on different outfits without physically trying them on, making fashion choices more accessible and enjoyable. ### GitHub Stars: 10 ### Installation: - Clone the repository: `git clone https://github.com/Cyanex1702/Virtual_Try_on_FashionGenAi.git` - Install dependencies: `pip install -r requirements.txt` - Download pre-trained U2Net model ### Usage: - Run the pipeline with the following command: ```bash python main.py --image <path_to_image> --prompt "A pink dress" --part upper --resolution 512 --output output.jpg ``` ### Model Details: - **Stable Diffusion Inpainting**: Fills in the clothing region. - **U2Net Segmentation**: Segments clothing parts. - **rembg**: Background removal. ### Examples

### Overview: GoVector is a lightweight, embeddable vector database written entirely in Go. It supports Qdrant-compatible API endpoints, HNSW indexing for fast approximate nearest neighbor search, and BoltDB-based persistent local storage. ### Key Features: - **Pure Go & CGO-Free**: Cross-compile to any platform (Windows, macOS, Linux, edge devices) without messy C/C++ dependencies. - **Unified CLI & Rich TUI**: A single `govector` binary for all operations (`serve`, `upsert`, `search`, `ls`, `rm`). Includes a beautiful, green-themed interactive Terminal User Interface (TUI) out of the box. - **High Performance**: Optimized for single-node performance, supporting millions of vectors with sub-millisecond search latency. - **HNSW Indexing**: Industrial-grade graph-based index for $O(\log N)$ search complexity, enabled by default with auto-creation. - **Protobuf & BoltDB**: Ultra-fast persistence using Protocol Buffers and bbolt. Data survives restarts with automatic collection discovery. - **Advanced Filtering**: Support for payload filtering (Exact, Range, Prefix, Regex, Contains) just like Qdrant. - **SQ8 Quantization**: Built-in 8-bit scalar quantization to reduce disk footprint for large-scale data. - **Reliability**: Over **92% test coverage** with nanosecond-precision versioning, storage-first consistency, and safe collection management (e.g., protecting the "default" collection). - **Dual Modes**: - **Embedded

### Overview: The Local Inference Optimizer skill is designed to assist agents like Claude Code and Codex in optimizing their LLM inference engines for specific hardware, models, and workloads. This skill helps agents determine the appropriate inference engine, configure a project using `uv` and `.venv`, and fine-tune various parameters such as kernels, quantization, context, batching, KV cache, and prefix cache. The skill also includes a health check and smoke test to ensure the server is functioning correctly. ### Key Features: - **Hardware Detection**: Determines the type of hardware (e.g., Apple Silicon, NVIDIA CUDA, AMD ROCm, Intel CPU). - **Engine Selection**: Chooses the best inference engine (e.g., MLX, llama.cpp, ExLlama, vLLM, SGLang, TensorRT-LLM). - **Project Setup**: Creates a project using `uv` and `.venv`. - **Parameter Tuning**: Configures kernels, quantization, context, batching, KV cache, and prefix cache. - **Server Verification**: Runs a health check and smoke test to ensure the server is operational. ### Tech Stack: The skill leverages Python and the Hermes framework to interact with hardware and perform inference optimizations. ### Why It Matters: This skill streamlines the process of optimizing LLM inference engines for specific hardware, models, and workloads, ensuring that agents can run their models efficiently and effectively. It is particularly useful for agents that need to run inference on a variety of hardware configurations, models, and workloads. ### Repository: The

Overview: This repository provides comprehensive guides and examples for deploying YOLO11 and DeepSeek-R1 on the RK3588 edge AI platform, utilizing RKNN and RKLLM for efficient inference. Key features: - YOLO11 deployment and multithread optimization tutorial in Python - DeepSeek-R1 deployment tutorial in llm/DeepSeek-R1 Tech stack: Python Why it matters: This repository offers practical, step-by-step instructions for deploying popular AI models on the RK3588 edge AI platform, ensuring efficient inference through the use of RKNN and RKLLM, making it valuable for developers working on edge AI projects.

Overview: This project automates the fine-tuning process of the OpenAI GPT-3.5 Turbo model by providing a Python script that uploads training data and waits for the job to complete. Key features: - Uploads training data file - Creates fine-tuning job - Waits for job completion Tech stack: Python Why it matters: This script streamlines the process of fine-tuning the GPT-3.5 Turbo model, making it easier for developers to experiment with and improve language models.

### Overview: EchoSwift is a powerful and flexible tool designed for benchmarking Large Language Model (LLM) inference. It allows users to measure and analyze the performance of LLM endpoints across various metrics, including token latency, throughput, and time to first token (TTFT). ### Key features: - Benchmark LLM inference across multiple Inference Servers - Measure key performance metrics: latency, throughput, and TTFT - Support for varying input and output token lengths - Simulate concurrent users to test scalability - Easy-to-use CLI interface - Detailed logging and progress tracking ### Tech stack: Python ### Why it matters: EchoSwift simplifies the process of benchmarking and configuration discovery for LLMs, making it easier for developers to optimize their models and ensure optimal performance. The tool's comprehensive metrics and flexible setup make it a valuable asset for anyone working with large language models.

Overview: This repository adds a native Gaudi2 backend to Strata, enabling a 512-expert Multi-Head Self-Attention (MoE) model with a 262,144-token context limit on a single Intel Gaudi2 card. Key features: - Native Gaudi2 backend - SynapseAI and TPC kernels - Custom TPC kernels sources - DFlash2 decode path - OpenAI/Anthropic-compatible API - Docker support Tech stack: C++ Why it matters: This implementation allows for efficient inference and decoding on a single Gaudi2 card, potentially accelerating downstream tasks and serving models in a compatible manner with OpenAI and Anthropic.

Overview: This project is a simple generative AI enabled Streamlit web application that converts speech to-image, providing text, speech, and image solutions for medical queries. Key features: - Speech-to-Image Conversion - Text-to-Speech - Speech-to-Text Tech stack: Python Why it matters: This project showcases the integration of various AI technologies, including LLMs, speech-to-text and speech-to-image functionalities, and the deployment of a Streamlit application, making it a valuable tool for personal projects and educational purposes.

Overview: Textmage is a website that generates images from text using the DALL-E generative model, powered by OpenAI. This project utilizes Python for its implementation and has been starred by 10 GitHub users. Key features: - Generates images from text using DALL-E - Supports training on the COCO dataset - Downloads and uses pre-trained weights for DALL-E - Provides a simple installation guide and deployment instructions Tech stack: Python Why it matters: This project demonstrates the capabilities of generative models like DALL-E in generating images from text, showcasing its potential applications in various fields such as art, design, and more.

Overview: KV-Direct is a bounded-memory inference scheme that replaces evicted key-value (KV) entries with residual checkpoints, achieving exactly zero reconstruction error and preserving 100% token match across various models. Key features: - Bounded-memory inference - Replacing evicted KV entries with residual checkpoints - Achieving exactly zero reconstruction error - Preserving 100% token match across models Tech stack: Python, PyTorch, and other standard libraries Why it matters: KV-Direct significantly reduces memory usage while maintaining high accuracy, making it ideal for large-scale language models and real-time applications where memory constraints are a bottleneck.

### Overview: nano-lmcache is an educational, step-by-step implementation of LLM KV cache reuse. It demonstrates the core ideas behind [LMCache](https://github.com/LMCache/LMCache) using Python modules, progressing from a prefix-cache demo to real Hugging Face tensors and an external KV cache for nano-vLLM. The project aims to explain each principle with minimal code, backed by runnable examples, correctness tests, and measured trade-offs. ### Key features: - **Prefix-Cache Demo**: Matches complete token chunks, stops at the first miss, and computes only the uncached suffix. - **Disk Demo**: Stores in memory or on disk; combines tiers with promotion on a slow-tier hit. - **Tiered Storage Demo**: Combines memory, disk, and tiered backends for shared-thread access. - **Real Model Tensor Demo**: Runs Hugging Face models on CPU or CUDA, offloads KV to pinned CPU memory, and serializes tensors losslessly or with optional lossy INT8 compression. - **Engine Integration**: Saves complete nano-vLLM KV blocks to external L2, loads them back into GPU blocks after restart, and reuses resident GPU L1 blocks on later requests. - **Viewer Tutorial**: View prefix trees, hit/miss decisions, eviction, promotion, and GPU import/export events in standalone HTML. - **Prefill/Decode Disaggregation**: Transfer checksummed KV between two toy-model roles, verify identical tokens without prompt recomputation, and simulate the scheduling trade-off. ### Tech Stack: Python ### Why

Overview: QuantumPDF V1.3 is a cutting-edge application that leverages quantum computing to enhance the interaction with PDF documents. It integrates Retrieval-Augmented Generation (RAG) to offer context-aware and accurate responses, making it a powerful tool for developers. Key features: - Quantum computing integration for enhanced document interaction - Retrieval-Augmented Generation (RAG) for accurate and context-aware responses Tech stack: TypeScript Why it matters: QuantumPDF V1.3 transforms the way developers interact with PDF documents by leveraging quantum computing and RAG, providing a more intelligent and contextually aware experience.

### Overview: This demo shows how to fine-tune a pretrained deep convolutional network called SqueezeNet to perform a crack/normal image classification. The classification output was discussed using a technique called grad-cam, which visualizes the importance of certain regions in the image. The script is based on the official documentation and references to additional explanations. The dataset used is from a concrete crack image dataset introduced by L. Zhang, available at [5]. ### Key Features: - Fine-tuning a pretrained deep convolutional network (SqueezeNet) for crack/normal image classification. - Discussing the classification output using grad-cam. - Using a dataset of concrete crack images introduced by L. Zhang. - Available at [5]. ### Tech Stack: MATLAB ### Why It Matters: This demo provides a practical example of how to use deep learning and explainable AI techniques to analyze and interpret the results of image classification tasks, specifically focusing on the importance of certain regions in the images.

Overview: This project is a chatbot equipped with LLM (Large Language Model) and RAG (Retrieval-Augmented Generation) technology, capable of answering questions based on content from any provided websites. Key features: - Integration of LLM for natural language understanding - RAG for improved response quality - Support for multiple languages - Dockerized application for easy deployment Tech stack: Python Why it matters: This project showcases the power of combining LLM with RAG, making it a valuable tool for developers looking to create intelligent chatbots that can handle complex questions across various domains. Repository: Koldim2001/RAG_LLM Primary language: Python GitHub stars: 10 GitHub description: A chatbot with LLM + RAG README excerpt: # RAG (Retrieval Augmented Generation) with LLM Сделано приложение, способное осуществлять QA при учитывании контента из любых предоставляемых сайтов. Надо передать список ссылок и далее можно задавать вопросы по данному материалу. --- ### Запуск сервисов: ``` docker compose up -d --build ``` Сайт по работе с LLM (chatbot with RAG) станет доступен после запуска компоуза по этому адресу - http://localhost:8501/ Код для работы с RAG из python - *rag_example.ipynb* Туториал по проекту - [видео](

### Overview: This project implements a human pose classifier using Visual Transformers (ViT), providing a comprehensive end-to-end pipeline for preprocessing, training, testing, and deployment. ### Key Features: - **Data Source**: Human action images from the Bingsu/Human_Action_Recognition dataset, preprocessed with the Hugging Face library. - **Model Architecture**: Fine-tuned ViT model for 15 action categories. - **AWS Integration**: Models automatically uploaded to S3 for easy retrieval during deployment. - **Deployment**: Model can be served on an EC2 instance. - **Web Interface**: Inference via FastAPI backend and Streamlit frontend. ### Tech Stack: Python ### Why it Matters: The model achieves high classification metrics, including an accuracy of 0.796, precision of 0.801, recall of 0.796, and F1-score of 0.798, making it highly effective for real-world applications.

### Overview: Governed Memory is an open-source project designed to provide a governed memory layer for enterprise AI agents. It ensures that every memory record carries provenance, trust labels, purpose bindings, and a tamper-evident audit trail. Agents can read only what they are authorized to read, enhancing security and reliability. ### Key Features: - **Prompt Injection-Resistant Writes**: Ensures that AI agents cannot inject malicious prompts into memory. - **Purpose-Bound Retrieval**: Agents can only retrieve data that is relevant to their purpose. - **Provenance and Audit Trail**: Every memory record has a provenance and a tamper-evident audit trail. - **Write Governor Pipeline**: A pipeline for scanning and deduplication before writes. - **Governed Retrieval Engine**: A hybrid search engine with a real privilege gate. - **Policy Engine**: Evaluates purpose bindings and privileged actions. - **Detection Module**: Trained injection classifier with tracked precision/recall. - **Audit Graph**: A formal hash-chain verifier for provenance lineage. - **REST API**: A self-hosted REST API covering memory, retrieve, quarantine, delete, and audit functionalities. - **Governed Write and Retrieve Flow**: A hosted demo for quick experimentation. ### Tech Stack: - **Python**: The primary programming language used for the project. ### Why It Matters: Governed Memory provides a secure and reliable memory layer for AI agents, preventing malicious activities, ensuring data integrity, and enhancing the overall security of AI systems. ### Repository: Repository: Metaworkers-ai/govern

### Overview: This project utilizes Qwen-Image-2.1 and the P-Q-Image-2.1 LoRA to generate 1024x1024 images from text prompts in 6 steps, offering a streamlined workflow for image generation. ### Key Features: - **Text-to-Image Generation**: Converts text prompts into high-resolution images. - **6-Step Adapter**: Simplifies the generation process by replacing the base model with the 6-step adapter. - **Model Composition**: Utilizes model-compose for efficient model management and optimization. ### Tech Stack: model-compose 0.4.121 or later, Qwen/Qwen-Image-2.1, and P-Q-Image-2.1 LoRA. ### Why It Matters: This project streamlines the image generation process, making it faster and more efficient compared to the base model. The 6-step adapter ensures consistent image quality without noticeable degradation. The project has been tested on various hardware setups, including a DGX Spark, RTX 4090, and MacBook M1 16GB, with results showing significant speed improvements and minimal impact on image quality.

### Overview: The project "Chat-Doc" aims to fine-tune the Llama2 model for medical diagnosis and chatbot functionality on AWS. This initiative is part of an applied deep learning course and focuses on end-to-end QLoRA-based fine-tuning for medical NLP tasks. ### Key Features: - Fine-tuning of Llama2 model for medical diagnosis and chatbot applications - Utilizes the QLoRA technique for efficient model training - Deployed on AWS SageMaker for training and inference ### Tech Stack: - Python - Jupyter Notebook - AWS SageMaker ### Why It Matters: This project demonstrates the integration of advanced natural language processing techniques with medical applications, aiming to provide reliable and accurate medical advice through a chatbot. The use of QLoRA and AWS infrastructure ensures efficient and scalable training and deployment of the model. ### Repository: - Repository: https://github.com/MisterXY89/chat-doc - GitHub Stars: 10 - GitHub Description: End-to-end QLoRA-based fine-tuning of Llama-2 for a medical-diagnosis/doctor chat-bot on AWS ### Project Type: - "Bring your own data" project ### Domain: - Natural Language Processing ### Project Overview: The ChatDoc project is designed to create a medical chatbot application that assists users in assessing their medical symptoms and providing reliable recommendations. The chatbot is powered by the Llama2 model, which is fine-tuned specifically for medical NLP tasks using the QLoRA technique. ### Getting Started: - Clone the