Skip to content

#教程/实践

Today 0 items
Sep 30Wed
Sep 29Tue
Sep 28Mon
Sep 26Sat
  1. GitHub Blog · AI & ML64

    GitHub Copilot app for Beginners: How to build custom workflows with canvases

    An official GitHub tutorial shows how to build custom workflows with canvases in the GitHub Copilot app: run the /create-canvas skill in an agent session, describe the workflow, user actions, and agent actions in natural language, and the agent generates boards, checklists, dashboards, and other interfaces that open in the side panel.

    Why it matters: The tutorial covers the three elements of /create-canvas and its two-way collaboration mechanism, so readers can turn their own workflows into reusable canvases.

  2. AWS Machine Learning Blog31

    Scaling MoE reinforcement learning on Amazon EKS with EFA and DeepEP with 40% more throughput

    AWS proposed an architecture based on Amazon EKS, EFA and DeepEP to accelerate large-scale reinforcement learning post-training of MoE models, delivering 40% higher throughput. The solution targets workloads like RLHF, PPO and GRPO, addressing resource balancing between rollout generation and policy training, high-throughput communication across hundreds of accelerators, and the dynamic all-to-all token routing overhead introduced by Expert Parallelism.

Sep 25Fri
  1. GitHub Blog · AI & ML68

    AI-powered fuzzing with the GitHub Security Lab Taskflow Agent

    Antonio Morales of GitHub Security Lab has released Fuzzing Taskflow, an autonomous fuzzing pipeline for C/C++ projects built on the Taskflow Agent — you only specify a GitHub repository, and it automatically identifies entry points, analyzes the build system, writes harnesses, runs AFL++, and triages crashes.

    Why it matters: The author explains the design of the automated fuzzing pipeline, showing how LLM agents can take over manual steps like coverage analysis and crash triage.

Sep 24Thu
  1. GitHub Blog · AI & ML60

    Rendering huge pull requests in the GitHub Copilot app

    The GitHub Copilot app team rebuilt the pull request view so it can smoothly open an open-source PR with 2,200 files, over one million changed lines, and more than 400 inline comments.

    Why it matters: The author offers a first-hand breakdown of the dual-geometry architecture and automated measurement methods for rendering huge PRs, useful for anyone building interfaces with large-scale dynamic content.

Sep 17Thu
  1. GitHub Blog · AI & ML77

    Migrating the GitHub Copilot runtime to Rust, using Copilot

    GitHub author Stephen Toub describes how the team, using the GitHub Copilot app and CLI, fully rewrote the Copilot agent runtime from TypeScript/Node.js into 832,378 lines of production Rust, with AI agents writing most of the code across 128 pull requests — a project that would normally take one or two person-years was completed by a single developer in a few months.

    Why it matters: The author lived through the entire migration and shares first-hand data on code volume, release cadence, and cache hit rates, offering a viable path for agent-driven large-scale rewrites.

Sep 12Sat
Sep 11Fri
  1. GitHub Blog · AI & ML49

    GitHub Copilot app for Beginners: Using the diff, terminal, and browser

    The GitHub Copilot app adds three built-in panels — diff, terminal, and browser — so you can review agent code changes, run commands, and preview results without leaving the app. The diff panel highlights added and removed lines in green and red, letting you accept changes, leave comments, or ask Copilot to revise; the terminal panel supports running scripts like npm run dev with multiple windows; and the browser panel uses the Pick & Polish tool to select elements for the agent to adjust.

Sep 10Thu
  1. Hugging Face Blog52

    Async GRPO with LoRA across HF Jobs: a bucket, a proxy, and no NCCL

    In TRL v1.14, Hugging Face enabled AsyncGRPOTrainer to support LoRA training, syncing only a few MB of adapters to vLLM. A Storage Bucket mount shares files between the trainer and two vLLM replicas, paired with a proxy that adds auth headers, routes requests by KV prefix, and broadcasts adapter loads—no NCCL cross-machine communication needed, cutting 500 steps from 3 hours 27 minutes to 53 minutes.

Sep 9Wed
Sep 4Fri
  1. GitHub Blog · AI & ML48

    GitHub Copilot app for Beginners: Run several agents at once

    The GitHub Copilot app supports running multiple AI agent sessions in parallel, with each session isolated on its own Git worktree so they don't interfere with each other and keep their own context. Users can track progress in the sessions view and switch between sessions at any time without re-explaining background. The article uses the tailspin-toys repository to demonstrate running three tasks simultaneously: adding a feature, an accessibility review, and running tests.

Sep 3Thu
  1. Hugging Face Blog62

    Training a coding model to paint watercolours with TRL and OpenEnv

    A Hugging Face blog author used TRL and OpenEnv to openly reproduce Surya Narreddi's approach, training Qwen/Qwen3.5-35B-A3B to write p5.brush code that paints watercolours.

    Why it matters: The author has open-sourced the training recipe, environments, reference pool, and model, so readers can reproduce the entire pipeline with a single command and learn from the troubleshooting notes.

Aug 26Wed
Aug 25Tue
Aug 21Fri
Aug 18Tue
  1. Hugging Face Blog71

    Multi-Vector (Late Interaction) Embedding Models with Sentence Transformers

    Hugging Face announced on its official blog that Sentence Transformers v6.0 adds a fourth model type, MultiVectorEncoder, supporting ColBERT-style late interaction retrieval; any PyLate and Stanford-NLP ColBERT checkpoint can be loaded directly, and colpali-engine models can also be used for visual document retrieval.

    Why it matters: Official tutorials cover the full pipeline of loading, scoring, indexing, and compression, so readers can use them to decide whether multi-vector retrieval is worth adopting in their own search stack.

  2. Hugging Face Blog37

    Same Cluster, 33 Points More Utilization: What Changed Was the Order

    Hugging Face built a constraint-aware GPU allocator and benchmarked it against a FIFO scheduler across seven scenarios. On identical hardware and workloads, GPU utilization rose by up to 33 percentage points (for example, from 53.6% to 87.0% for an 8-GPU training-heavy workload), priority-weighted output increased in every scenario by up to 105%, averaging 52%. The key change is allocating real-time inference demand across time steps along its curve and placing batch-like tasks by priority across the whole scheduling horizon, rather than assigning by arrival order.

Aug 14Fri
Aug 11Tue
Aug 10Mon
Jul 16Thu
  1. Hugging Face Blog32

    Newer Models, Same Advantage

    DharmaOCR scored 0.925 on a Brazilian Portuguese OCR benchmark, beating the newer Mistral OCR4 (0.798) and Unlimited-OCR (0.7587), confirming the value of domain specialization. The model uses supervised fine-tuning to align with Brazilian Portuguese vocabulary and document structure, then DPO to suppress repetitive or incoherent output, achieving the lowest degradation rate. The article argues that the reliability of generative OCR depends on how concentrated the parameters are within a single domain, not on a larger architecture.

Jul 10Fri
  1. Hugging Face Blog61

    Profiling in PyTorch (Part 3): Attention is all you profile

    Hugging Face published part three of its Profiling in PyTorch series, using the profiler on an NVIDIA A100 to compare traces of six attention implementations: naive attention, in-place masking, and SDPA math/efficient/flash/cuDNN.

    Why it matters: The original benchmarks kernel-level differences across six attention implementations with the profiler, teaching readers to read from traces how in-place saves a copy and what each SDPA backend really costs.

Jul 6Mon
  1. Hugging Face Blog47

    PRX Part 4: Our Data Strategy

    Hugging Face details the data pipeline for its PRX image generation model: mixing public and internal datasets for pretraining, using a VLM to regenerate long captions, then converting them into streamable training data. The text encoder has been switched to Qwen3-VL, with text latents computed online during training at a throughput cost of only about 3–4%. Images are uniformly encoded as JPEG quality 92, and the data is built with Lance and streamed for training via MDS (Mosaic Streaming).

Mar 11Wed
Jan 22Thu
  1. Mistral AI62

    Heaps do lie: debugging a memory leak in vLLM.

    The Mistral AI team investigated a memory leak of roughly 400 MB per minute in vLLM when running Mistral Medium 3.1 with graph compilation enabled in P/D disaggregated deployments.

    Why it matters: The article documents the full process of localizing the leak layer by layer from pmap and BPFtrace to GDB, which can be applied to similar kernel-level debugging of inference services.

Aug 1Fri
Apr 9Wed