gpttools is an R package that extends RStudio with large language model (LLM) capabilities for R package development. It provides a suite of RStudio addins for tasks such as generating roxygen documentation, suggesting unit tests, converting scripts to functions, and a Copilot-style ghost text writer. The package also includes a retrieval-augmented generation (RAG) system that scrapes documentation, creates embeddings, and indexes them for context-aware chat. It supports multiple AI providers (OpenAI, Anthropic, Perplexity, Cohere, Ollama, Azure OpenAI, Google) via a modular streaming handler pattern, and offers both cloud-based and local (sentence-transformers, Ollama) embedding options. The architecture is a mix of R functions, Shiny apps (settings, retrieval chat, data documentation), and Python integration via reticulate for local models. Key entry points include the addins, the chat() function, chat_with_context() for RAG, and the crawl() function for building indexes. External dependencies include the gptstudio package, various LLM APIs, and a Python environment for local embeddings. While primarily an application, it incorporates data engineering patterns for scraping, chunking, embedding, and indexing documentation.
text2vec is a Python library for converting text (words, sentences, paragraphs) into dense vector embeddings, with a strong focus on Chinese semantic similarity. It provides multiple embedding backends: Word2Vec (Tencent embeddings), Sentence-BERT, CoSENT, BGE, and BM25 for lexical ranking. The library offers a unified API via `SentenceModel` and `Similarity` classes, a command-line interface for batch embedding, and training/fine-tuning scripts for supervised and unsupervised text matching. It also includes deployment examples (FastAPI, Jina, Gradio) and evaluation benchmarks (C-MTEB, MTEB). While primarily an application/library, it has strong research components with detailed model comparison reports and dataset building scripts. The codebase is modular and well-documented, though some training code contains boilerplate repetition and dependency version ranges are broad, introducing potential drift.
This repository provides a comprehensive toolkit for Chinese Llama-3 models, including base and instruction-tuned versions. It offers scripts for pre-training, fine-tuning, model merging, inference (via Hugging Face transformers, llama.cpp, Ollama, and OpenAI API-compatible server), and evaluation on standard benchmarks (CEval, CMMLU, MMLU, LongBench). The repository follows a modular architecture where each functionality is implemented in separate scripts under the scripts/ directory. Key entry points include training scripts (run_clm_pt_with_peft.py, run_clm_sft_with_peft.py), inference scripts (inference_hf.py, llama_cpp/chat.sh, openai_api_server.py), and evaluation scripts (ceval/eval.py, cmmlu/eval.py, etc.). The model supports LoRA adapters for efficient fine-tuning and provides merging utilities to combine base models with LoRA weights. The code demonstrates good practices in handling model quantization, PEFT integration, and multi-platform deployment.
monkeSearch is a macOS-native file search tool that uses a local LLM to parse natural language queries into structured search parameters, then executes Spotlight searches via PyObjC. The system breaks queries into file type indicators (with specificity detection), temporal expressions, and residual keywords, converting them to NSPredicates using UTIs for file type matching and date comparisons for temporal filtering. It features a clean separation between LLM-based query parsing (query_gen.py) and Spotlight execution (parser.py), with the former being particularly well-engineered for reuse. The tool is designed for offline, agentic use with no cloud dependencies, targeting low-resource environments.
nlpaug is a Python library for data augmentation across text (character, word, sentence), audio, and spectrogram modalities. It provides a wide array of augmentation techniques including random insertion/substitution/deletion, synonym replacement via WordNet/PPDB, contextual word embeddings (BERT, GPT-2, RoBERTa), back-translation, TF-IDF-based augmentation, keyboard/OCR error simulation, and audio effects (noise, pitch shift, speed, VTLP). The library follows a consistent pattern: each augmenter inherits from a base class, accepts data via a unified `augment()` method, and returns augmented samples. Composition is supported through `Sequential` and `Sometimes` pipeline classes. It relies heavily on external deep learning models (HuggingFace Transformers, word2vec, GloVe, fastText) and audio processing (librosa). The codebase is well-structured with clear separation of concerns (augmenters, models, utilities, flows), extensive unit tests, and documentation. However, it exhibits significant technical drift due to aggressively pinned dependencies (e.g., `transformers>=5.9.0`, `numpy>=2.4.6`) that may not exist or conflict with current stable releases, and some integration code (conda setup for Python 3.5–3.9) is outdated. Despite this, the core augmentation logic and utility modules are sturdy and reusable.
This repository is an educational tutorial for Apache Spark using Scala, designed to teach distributed data processing concepts through practical examples. It functions as a data research and engineering learning resource, featuring Jupyter notebooks and Scala source code that demonstrate RDD operations, SparkSQL, and streaming pipelines. The project includes bundled datasets such as the King James Version Bible and the Enron Spam/Ham email corpus, along with golden output files for test verification. While it serves as a comprehensive guide for Spark development, it primarily focuses on teaching data transformation patterns rather than deploying a production service. The codebase demonstrates solid engineering practices for an educational context, including unit tests, custom utility classes for CLI argument parsing, and structured data schemas. However, the technical stack is significantly outdated, relying on Spark 2.3.0 and Scala 2.11.8, which are no longer supported. The examples frequently use deprecated APIs, such as the RDD-based DStream for streaming, which has been superseded by Structured Streaming in modern Spark versions. This creates a high technical drift, making the code less suitable for new projects without significant refactoring. Despite the outdated dependencies, the repository remains a valuable resource for understanding Spark fundamentals. The inclusion of golden files and test utilities provides a reproducible framework for validating data processing logic. The tutorial structure progresses logically from basic word counts to complex SQL and streaming operations, making it effective for learning. Users should be aware that while the patterns are sound, the specific API implementations will require updates to align with current Spark LTS versions.
This repository is primarily an educational resource for teaching data science and machine learning concepts. It contains a extensive collection of Jupyter notebooks, Python scripts, and supporting materials covering topics from basic statistics and pandas to advanced deep learning, NLP, and LLMs. The content is organized as tutorials and examples rather than a cohesive application, with numerous datasets included for hands-on learning. The repository appears to be actively maintained with recent updates, suggesting efforts to keep the educational content current with evolving technologies.
This repository is the companion code for the O'Reilly book 'Hands-On Large Language Models' by Jay Alammar and Maarten Grootendorst. It provides 12 chapters of Jupyter notebooks covering fundamental and advanced LLM topics including tokenization, embeddings, text classification, clustering, prompt engineering, semantic search, multimodal models, fine-tuning, and generation. All notebooks are designed to run on Google Colab with free GPU resources and rely heavily on Hugging Face libraries (transformers, datasets, sentence-transformers, TRL) and external APIs (OpenAI, Cohere). The code is educational in nature, with clear step-by-step explanations and visualizations. While it is not a production application or a novel research pipeline, it serves as a high-quality, reproducible tutorial resource for practitioners learning LLM workflows. The repository includes pinned dependencies, Conda environment setup, and local installation guides, making it relatively easy to reproduce in a controlled environment, though API keys are required for some sections.
This repository is the official companion code for the O'Reilly book 'Natural Language Processing with Transformers' by Tunstall, von Werra, and Wolf. It contains 11 Jupyter notebooks, one per chapter, covering the full spectrum of NLP with Transformers: text classification, named entity recognition, text generation, summarization, question answering, model compression, few-shot learning, and training a transformer from scratch. The code is built on the Hugging Face ecosystem (transformers, datasets, accelerate) and is designed to be run interactively on Colab, Kaggle, or local GPU environments. The notebooks are well-structured with clear section headings, explanatory text, and visualizations, making them an excellent educational resource for learning state-of-the-art NLP techniques. Although the repository is primarily educational, it includes a SageMaker adaptation for some chapters, demonstrating deployment of Hugging Face models on AWS. The codebase is not intended as a production-grade library; rather, it serves as a tutorial and reference for practitioners. The overall quality is solid, with clean, reproducible code patterns, but the reliance on pinned, outdated library versions (e.g., transformers 4.16.2, datasets 1.16.1) and the deprecated Chapter 7 (farm-haystack) indicate moderate technical drift. The concepts remain relevant, but the exact code may require adjustments to run with the latest versions.
This repository implements and evaluates Function Vectors (FVs) for steering large language models (LLMs) without fine-tuning. The core workflow involves computing task-conditioned mean head activations from in-context learning examples, identifying causally influential attention heads via indirect effect, summing their outputs to form the FV, and applying it during inference to elicit target behaviors (e.g., translation, inflection). The system provides a modular Python library with utilities for model loading, prompt construction, activation extraction, intervention, and evaluation, accompanied by a demo notebook and evaluation scripts for running experiments on various linguistic datasets. While the codebase demonstrates clean separation of concerns and contains reusable components for model intervention and prompt handling, it shows signs of technical drift due to dependency rigidity and architecture-specific hooks, and appears to have stagnated in maintenance with no recent updates.
bertviz is a Python library for interactive visualization of attention in Transformer-based NLP models. It provides three complementary views: Head View (per-head attention patterns), Model View (attention flow between tokens across layers), and Neuron View (query/key interactions within individual attention heads). The library is designed for Jupyter notebooks, rendering D3.js-based interactive HTML directly in cell output. It accepts attention tensors from most HuggingFace models via output_attentions=True, and includes a vendored, modified copy of older HuggingFace transformers code to expose query/key vectors for the Neuron View on BERT, GPT-2, RoBERTa, XLNet, and similar architectures.
This repository is a knowledge base and documentation collection rather than a software application or data pipeline. It contains 117+ markdown files with interview questions and answers focused on Large Language Models (LLMs), Transformers, RAG, and Prompt Engineering. The content is curated by a single author and serves as a study resource for AI/ML engineers preparing for technical interviews. There is no executable code, data processing logic, or model training scripts present. The repository structure is flat and consistent, grouping questions into logical batches (e.g., QA_1-3.md, QA_4-6.md). While it lacks engineering artifacts like tests or CI/CD pipelines, the documentation quality is high, with clear formatting, consistent answer structures, and cross-references to related repositories. It is best suited for learners seeking structured knowledge rather than engineers looking for reusable code components. The content is static and does not require environment setup or data ingestion, making it highly reproducible in terms of accessibility. However, as a documentation repo, it does not offer the architectural depth or component reusability typical of software engineering projects. The 'active' maintenance status is derived from the provided metadata timestamp, though the content itself is static text.
soynlp is a pure-Python library for unsupervised Korean natural language processing, providing statistical methods for tokenization, noun extraction, POS tagging, lemmatization, and text normalization. The architecture is modular, with subpackages for hangle (Hangul decomposition/composition), lemmatizer, normalizer, noun extraction (v1, v2, news), POS tagging (dictionary-based and LR-template-based), tokenization (LTokenizer, MaxScoreTokenizer, RegexTokenizer), vectorization (TF-IDF-like), word extraction (cohesion, branching entropy), and utility data structures (LRGraph, EojeolCounter). Key entry points include WordExtractor, LRNounExtractor_v2, LTokenizer, MaxScoreTokenizer, BaseVectorizer, and DoublespaceLineCorpus. Data flows typically involve reading a corpus of double-space-separated sentences, building LR substring frequency graphs, extracting word/noun scores, and then using those scores for tokenization or tagging. External dependencies are limited to numpy and scikit-learn (older versions). The repository also includes research-oriented tutorials (Jupyter notebooks) and pre-built linguistic resources (frequency dictionaries, trained noun predictors), making it a hybrid of a production library and a research codebase. The unsupervised approach is well-suited for homogeneous document collections where domain-specific adaptation is needed.
This repository is a curated collection of machine learning interview questions and answers, organized by topic (ML fundamentals, deep learning, computer vision, NLP, statistics, coding). It is primarily a documentation site, with a Python build script that generates a static website from the README.md and NLP/README.md files. The site is deployed to GitHub Pages via a CI/CD workflow. The codebase is minimal: the only executable code is the build script, which parses markdown, generates HTML pages with SEO metadata, JSON-LD structured data, sitemap, and robots.txt. The repository is not an application or data pipeline; it is a knowledge base with a static site generator. The build script is well-structured and demonstrates good practices for generating a static site from markdown sources.
This repository is a curated collection of baseline solutions for data science competitions, primarily from Chinese platforms (科大讯飞 AI开发者大赛, Tianchi, DataFountain, AIWIN, etc.) and some international ones (Kaggle). It contains hundreds of Jupyter notebooks and Python scripts covering a wide range of tasks: structured data classification/regression (LightGBM, XGBoost), computer vision (ResNet, EfficientNet, YOLO, CRNN), natural language processing (BERT, TF-IDF, Qwen), time series forecasting, and multimodal challenges. Each baseline is self-contained, providing a quick-start pipeline from data loading to submission generation. The repository serves as a practical learning resource for competition participants, demonstrating common feature engineering techniques, model training loops, and ensemble strategies. However, the code quality is uneven: many notebooks are exploratory with hardcoded paths, outdated library versions, and minimal error handling. The repo lacks centralized dependency management, environment definitions, or modular reusable libraries, making reproducibility low without manual adaptation. Despite these limitations, it offers a valuable catalog of patterns and templates that can be adapted for new competitions.
This repository is a comprehensive collection of AI model demos and sample applications for Sophgo's Sophon TPU hardware (BM1684X, BM1688, CV186X). It provides both Python and C++ implementations for running inference on a wide range of models including object detection (YOLO variants, CenterNet), segmentation (SAM, YOLACT), OCR (PP-OCR, LPRNet), large language models (Qwen, ChatGLM, MiniCPM), speech recognition (Whisper, WeNet), text-to-speech (ChatTTS, VITS), and multi-modal models (CLIP, BLIP, GroundingDINO). The repository also includes full application demos such as a document QA chatbot (ChatDoc), an audio assistant pipeline (ASR+LLM+TTS), multi-channel video processing with Qt GUIs, and OpenAI-compatible API servers. The primary architecture is a set of independent, self-contained demos, each with its own model compilation scripts (using TPU-MLIR), inference code, and evaluation tools. While the codebase is functional and covers a broad spectrum of AI models, it suffers from significant code duplication across samples, hardcoded paths, and some outdated dependency versions, making it more of a demo showcase than a production-ready library.
This repository is a curated educational resource and learning roadmap for Large Language Models (LLMs), rather than a software application or data pipeline. The entire substantive content is contained within a single README.md file, which is structured into three major learning tracks: 'LLM Fundamentals' (math, Python, neural networks), 'LLM Scientist' (building LLMs, pre-training, fine-tuning, alignment, quantization), and 'LLM Engineer' (RAG, agents, deployment, optimization, security). Each section provides annotated links to external resources—notebook tutorials, blog posts, papers, videos, and tools—rather than hosting original code or data assets. There are no source code files, notebooks, data files, configuration files, or dependency manifests in this repository beyond the README and a LICENSE file. The repository links to several external Colab notebooks hosted on Google Drive (covering tools like LazyMergekit, AutoQuant, and LazyAxolotl, and tutorials on fine-tuning, quantization, and model merging), but these are not part of the repository itself. The repo functions as a reading list and structured syllabus, not as a codebase. From a data engineering or software reuse perspective, there are no reusable components within this repository—no ETL scripts, no data validation routines, no model training code, no configuration schemas, and no test suites. The value lies entirely in the curation and organization of external educational materials. The repository was last committed to in February 2026 and has no CI/CD, no package manifests, and no code-level maintenance concerns.
This is a research repository from the SCIR-HI lab at Harbin Institute of Technology, focused on instruction-tuning large language models (LLaMA, Alpaca, Bloom, Huozi) with Chinese medical knowledge. The core contribution is the construction of Chinese medical instruction datasets using structured knowledge bases (cMeKG) and medical literature via GPT3.5, followed by LoRA-based fine-tuning. The repository provides scripts for fine-tuning, inference, and model export, along with pre-trained LoRA weights. While it demonstrates a complete research pipeline (data generation, training, evaluation), it is primarily a research artifact rather than a production application. The code is functional and includes a clean, reusable Prompter class for template management, but lacks software engineering rigor (no tests, no CI). Reproducibility is moderate: dependencies are pinned, but the data generation process is not fully automated, and external base models and LoRA weights must be obtained separately.
This is the Qualcomm Innovators Development Kit (QIDK), a collection of Android sample applications and tools demonstrating on-device AI inference using the Qualcomm Neural Processing SDK (SNPE) and Qualcomm Neural Network (QNN) runtime. The repository covers computer vision (object detection, pose estimation, super-resolution, image enhancement), NLP (sentiment analysis, question answering, automatic speech recognition), and generative AI (LLM chat, speech-to-image, ASR-LLM-TTS pipeline). Each solution is a standalone Android app with native C++ JNI code that integrates the SNPE/QNN SDK for accelerated inference on Snapdragon platforms. The repository also includes tools like `pysnpe_utils` (Python library for model conversion and execution), `snpe-helper` (Python wrapper for SNPE runtime), and low-level Hexagon compute examples (QHCI/HVX). While the codebase is functional and covers a wide range of use cases, it suffers from significant code duplication across solutions, hardcoded paths, and version coupling to specific SDK releases. The architecture is a collection of loosely coupled sample apps rather than a unified framework, limiting cross-project reuse. The commit history shows ongoing maintenance, but the last commit date appears anomalous (2026), and several files reference future copyright years, suggesting pre-release content.
This repository is an educational book/course (DataWhale 'diy-llm') that teaches building and training LLMs from scratch. It spans the full pipeline: tokenizer, Transformer architecture, GPU high-performance programming, scaling laws, data engineering, distributed training, alignment (including GRPO/RLVR), evaluation, and multimodal models. The content is primarily Chinese, with Jupyter notebooks and code snippets embedded in markdown chapters. It is not a production library or application; it is a tutorial/textbook with homework assignments.