FractalWorkspace README

项目的 README,来自 github.com/Fractal-Compute-Orchestrations/FractalWorkspace。合并为一个 markdown 文件:README.md。

Fractal Banner

Fractal

Distributed Compute Orchestration and Edge Intelligence Framework

License Platform Open In Colab Design Status Architecture Organization

A unified distributed systems framework bridging centralized model orchestration with decentralized edge intelligence.

Overview | Key Results & Benchmarks | Industry & Community Recognition | Subsystems | Architecture | Operational Paradigms | Global Contracts | Academic Foundations | Getting Started


Fractal-Compute-Orchestrations%2FFractalWorkspace | Trendshift

Fractal-Compute-Orchestrations%2FFractalWorkspace | Trendshift Fractal-Compute-Orchestrations%2FFractalWorkspace | Trendshift Fractal-Compute-Orchestrations%2FFractalWorkspace | Trendshift

Overview

Executive Summary: The Core Breakthrough & Bottom Line

The Problem: Foundation models (TinyLlama, Llama-3, Mistral) cannot participate in decentralized edge federated learning because consumer mobile devices face three compounding physical bottlenecks:

  1. The Uplink Bottleneck: Transmitting uncompressed model checkpoints (4.2 GB to 30.5 GB) over consumer Wi-Fi/LTE (5 to 10 Mbps) requires 5 to 10 minutes per client, triggering aggregator timeouts (120s cutoff) and dropping edge nodes.
  2. The Dynamic Range Collapse: Standard 4-bit quantization breaks modern attention projections; emergent outliers inflate global scales, squashing 99.9% of normal weights into zero bins, collapsing Layer 5 cosine fidelity to 0.6990, and inducing catastrophic training divergence.
  3. The Mobile Memory Wall (LMK): Checkpoint loading exceeds mobile RAM limits, triggering immediate Android Low Memory Killer (LMK) process evictions and battery overheating.

The FRACTAL Achievement: FRACTAL breaks all three physical walls through hardware-aligned algorithmic co-design:

  • 7.11x Wire Payload Reduction (85.94% Wire Cut): Parameter payload drops from 4,196 MB down to 590 MB for TinyLlama-1.1B, and from 30.5 GB down to 4.29 GB for Llama-3 8B.
  • Sub-60s Transmission Guarantee: Slashes 10 Mbps upload duration from 321.2 seconds down to 46.2 seconds, beating the 120s federated aggregation deadline by 73.8 seconds.
  • Zero Accuracy Collapse (0.9878 Fidelity Preserved): Micro-block dynamic scaling (64-element tiles) confines attention projection outliers locally, sustaining 0.9878 mean cosine similarity and 4.3e-5 MSE across all 22 layers, matching lossless 16-bit convergence.
  • Zero Mobile LMK Crashes: Native memory-mapped execution (mmap) and an 85.6% reduction in radio transmission time keep mobile nodes thermally cool and crash-free.

Fractal is a high-performance distributed computing ecosystem engineered to harvest fragmented consumer compute across mobile edge devices while strictly preserving user privacy and device health. The framework treats edge devices not merely as remote processors, but as autonomous, resource-constrained nodes operating under human-centric constraints.

The Frontier Challenge

Centralized foundation model training and inference face compounding physical and financial bottlenecks:

  1. The Centralized Compute Monopoly: Foundation model adaptation is concentrated in capital-intensive GPU clusters consuming megawatts, while billions of consumer edge devices with dedicated neural engines sit idle on chargers.
  2. The Asymmetric Uplink Wall: Edge mobile devices operate over asymmetric wireless links (often limited to 5 to 10 Mbps upload). Transmitting full FP32 (4.2 GB) or FP16 (2.1 GB) parameter checkpoints across edge nodes leads to multi-minute transfer latencies, radio thermal accumulation, and severe client dropouts.
  3. The Outlier Collapse in Low-Bit Quantization: Naive 4-bit edge parameter quantization fails in modern transformers. High-magnitude feature outliers in attention projections inflate global scaling factors, squashing 99.9% of normal weights into zero bins and dropping layer cosine similarity to 0.699.
  4. The Mobile Memory Wall (LMK): Loading multi-gigabyte foundation models exceeds mobile RAM budgets, triggering aggressive Android Low Memory Killer (LMK) process evictions.

The Fractal Architecture

Fractal resolves these compounding bottlenecks through two unified, production subsystems:

  1. FractalCore (Central Server & Model Slicer): The Python control plane executing multi-tenant isolation, dataset segment allocation, ATen graph compilation and memory-bounded slicing, deterministic federated weight aggregation (FedAvg/FedProx), compute budgeting, and tokenized reward distribution.
  2. FractalAndroid (Edge Compute Node & Runtime): The native Kotlin execution engine running on mobile hardware. It performs hardware-gated on-device training and memory-mapped inference, dynamically pausing workloads if thermals or battery thresholds are exceeded.

Empirical Benchmarks & Performance Evaluation

To rigorously evaluate FRACTAL under real-world distributed constraints, we benchmarked our block-wise dynamic INT4 quantization and partitioned model execution pipeline across 253,755,392 float32 parameters from TinyLlama-1.1B (22 layers, 2048 hidden dimension, 5632 intermediate dimension) and MobileNetV3. All metrics are directly calculated from matrix tensor operations and physical network transport models.

Executive Performance Summary

Metric Dimension Uncompressed Baseline (FP32) Half-Precision (FP16) Standard Uniform INT8 (QSGD) Global Tensor INT4 FRACTAL Micro-Block INT4 Empirical Impact
TinyLlama Wire Payload 4,196 MB 2,098 MB 1,049 MB 524 MB 590 MB 7.1x wire payload reduction
Reconstruction Fidelity 1.0000 >0.9999 0.9924 0.8296 (Fails) 0.9878 Zero divergence across 22 layers
Mean Squared Error (MSE) 0.000000 <0.000001 0.000018 0.000433 0.000043 10x lower error vs Global INT4
10 Mbps Uplink Latency (100M) 321.2 s 161.2 s 81.2 s 41.2 s 46.2 s 86% reduction in radio duty cycle
Training Viability Lossless (Stable) Lossless (Stable) High Fidelity (Stable) Catastrophic Divergence Pareto Optimal (Stable) Enables true 4-bit edge convergence

Comparative Pareto-Optimal Compression & Fidelity

Method / Framework Target Representation TinyLlama-1.1B Payload Wire Reduction Ratio Mean Layer Cosine Sim 10 Mbps Uplink Latency Physical Hardware Impact Edge Index (EOI) Training Viability
FRACTAL (Micro-Block INT4) Packed Int4 + Scale 590 MB 7.1x 0.9878 46.2 s mmap streaming (Zero LMK) 92 / 100 PARETO OPTIMAL (Stable)
Flower (QSGD INT8) Uniform Int8 1,049 MB 4.0x 0.9924 81.2 s Standard Python/JVM heap 71 / 100 High Fidelity (Stable)
NVIDIA FLARE (Enterprise) Float16 (16-bit) 2,098 MB 2.0x >0.9999 161.2 s High Ingress Saturation 65 / 100 Lossless (Stable)
FedML (HeteroFL Slicing) Dynamic FP16 ~1,500 MB 2.8x 0.9650 ~110.0 s Sub-graph slicing overhead 61 / 100 Moderate Fidelity
PySyft (OpenMined INT8) Int8 Encrypted 1,049 MB 4.0x 0.9900 81.2 s Cryptographic CPU drain 56 / 100 Secure Aggregation (Stable)
TensorFlow Federated (TFF) Float32 Baseline 4,196 MB 1.0x 1.0000 321.2 s Frequent Mobile LMK Eviction 48 / 100 Severe Edge Stragglers
PyTorch RPC (Uncompressed) Float32 Baseline 4,196 MB 1.0x 1.0000 321.2 s Thermal Throttling (>42°C) 44 / 100 Raw Socket (Unsafe Edge)
Global Tensor INT4 Standard Int4 524 MB 8.0x 0.8296 41.2 s Low wire, zero convergence 21 / 100 FAILS: Severe Divergence

Critical Note on Global INT4 vs FRACTAL: While Global INT4 appears 5 seconds faster on paper (41.2s vs 46.2s), it is completely unviable in practice. Single attention outliers inflate the global scale factor, forcing 99.9% of normal weights into zero bins and causing model output to collapse (cosine similarity dropping to 0.699 in deeper layers). FRACTAL pays a negligible 5-second scale overhead to rescue fidelity from 0.8296 back to 0.9878, making 4-bit edge training actually converge.


Empirical Visualizations & In-Depth Technical Analysis

The empirical evaluation of FRACTAL measures physical transmission payloads, numerical reconstruction fidelity, and wireless uplink synchronization latencies using real matrix parameters extracted from TinyLlama-1.1B and MobileNetV3.

Figure 1: Distributed Parameter Wire Payload Across Foundation Model Scales

Distributed Parameter Wire Payload vs Precision Format

Figure 4: The Distributed Compute & Quantization Frontier (Pareto Optimality Map)

The Distributed Compute and Quantization Frontier Pareto Optimality Map

Figure 5: Distributed Edge Efficiency Index (Artificial Analysis Style Frontier Ranking)

Distributed Edge Efficiency Index Leaderboard

Figure 2: Layer-Wise Numerical Fidelity and Transformer Outlier Collapse

Layer-Wise Reconstruction Fidelity Across Transformer Depth

Edge Round Parameter Synchronization Latency vs Uplink Bandwidth

Reproducing the Benchmarks

The complete benchmark suite executes directly on CPU using real matrix tensors and requires no external GPU clusters:

# Run matrix evaluation and regenerate all publication figures
python scripts/benchmark_evaluation.py

Mathematical Formulation: Micro-Block Dynamic Scaling (MB-DS)

In transformer architectures, linear projections across multi-head self-attention and feed-forward networks (FFN) govern the primary parameter volume: $$W_q, W_k, W_v, W_o \in \mathbb{R}^{d_{\text{model}} \times d_{\text{model}}}, \quad W_{\text{gate}}, W_{\text{up}} \in \mathbb{R}^{d_{\text{ffn}} \times d_{\text{model}}}, \quad W_{\text{down}} \in \mathbb{R}^{d_{\text{model}} \times d_{\text{ffn}}}$$ During model training and adaptation, these matrices exhibit emergent heavy-tailed feature outliers where a minute fraction of parameters (less than 0.1%) reach magnitudes exceeding ten times the layer standard deviation ($|w| > 10\sigma_W$).

1. Outlier Collapse in Global Uniform Quantization

Standard uniform 4-bit quantization computes a single global scale across the entire weight tensor $W \in \mathbb{R}^{M \times N}$: $$\gamma_{\text{global}} = \frac{\max_{w \in W} |w|}{7.0}$$ When an extreme outlier satisfies $|w^*| \ge 10\sigma_W$, the global divisor becomes $\gamma_{\text{global}} \ge 1.43\sigma_W$. For normal in-distribution parameters satisfying $|w_i| \le 0.5\sigma_W$, the normalized quotient falls below the quantization threshold: $$\left| \frac{w_i}{\gamma_{\text{global}}} \right| \le \frac{0.5\sigma_W}{1.43\sigma_W} \approx 0.35 < 0.50$$ The nearest-integer rounding operator maps these parameters directly to zero: $$q_i = \text{clamp}\left( \left\lfloor \frac{w_i}{\gamma_{\text{global}}} \right\rceil, -8, 7 \right) = 0$$ This dynamic range collapse decimates $99.9%$ of active weight trajectories. Layer cosine similarity craters to 0.8296 overall (and 0.6990 in deeper self-attention projections), destroying gradient directionality and inducing catastrophic divergence during federated weight averaging.

2. The FRACTAL Micro-Block Solution and Spatial Error Confinement

FRACTAL eliminates global dynamic range collapse by partitioning flattened parameter arrays into micro-blocks of $B_k \in \mathbb{R}^{64}$: $$\gamma_k = \frac{\max_{w \in B_k} |w|}{7.0}$$ $$q_i = \text{clamp}\left( \left\lfloor \frac{w_i}{\gamma_k} \right\rceil, -8, 7 \right), \quad \forall w_i \in B_k$$ Pairs of signed 4-bit values $q_{2j}$ and $q_{2j+1}$ are bit-packed into single uint8 bytes: $$\text{packed}j = (q{2j} \ & \ \text{0x0F}) \ | \ ((q_{2j+1} \ & \ \text{0x0F}) \ll 4)$$


Industry & Community Recognition

The architectural breakthroughs, hardware telemetry gating, and sub-byte parameter quantization methods introduced in Fractal have garnered significant independent analysis from systems engineering communities and edge artificial intelligence researchers.

Technical Analysis Series (CSDN GitBlog)

A multi-part architectural deep dive published on CSDN GitBlog examines Fractal's low-level systems implementation across edge orchestration, memory management, and model graph compilation:

  1. System Architecture & Distributed Workspace Topology: Architectural evaluation of Fractal's decoupled repository structure, master-worker control plane separation, and distributed coordination between server infrastructure and edge Android runtimes.
  2. Hardware-Telemetry Protection Gating & Battery Preservation: Systems analysis of consumer device protection policies, including 80% battery capacity gating, sub-40°C thermal cutoffs, and unmetered network policies designed to prevent device wear.
  3. Model Compilation & ATen Graph Slicing into Memory-Safe PTE: Deep dive into the inference-model-maker/slicer toolchain, covering ATen static tracing, XNNPACK backend lowering, and dynamic .pte sub-graph generation tailored for edge memory limits.
  4. Zero-Copy Memory-Mapped Execution (mmap) & Android LMK Protection: Examination of native memory mapping techniques that eliminate process termination triggered by the Android Low Memory Killer (LMK), enabling multi-billion parameter partition execution on consumer hardware.
  5. Control Plane Security, Stateless Token Ingress, and REST API: Comprehensive review of FractalCore's stateless X-Auth-Token ingress gateway, filesystem-level tenant data isolation, and single-use task dispatch replay protection.
  6. Decentralized Scheduling & Deterministic Parameter Aggregation: Mathematical and architectural audit of master-worker task queues, client checkpoint validation mechanisms, and deterministic Federated Averaging (FedAvg) synchronization.

Media & Community Features


Ecosystem Subsystems

Central Server (FractalCore) Edge Compute Node (FractalAndroid)
Tenant Dashboard

Multi-Tenant Dashboard: Real-time fleet tracking, segment dispatch, and live aggregation telemetry.

Android Active Node

Edge Node: On-device training & telemetry.


System Architecture

Fractal operates on a hierarchical Master-Worker architecture designed to isolate control signals from mathematical payloads.

graph TD
    subgraph ControlPlane ["Control Plane (FractalCore Server)"]
        direction TB
        API["REST Gateway & Auth Controller"]
        TM["Tenant Isolation Manager"]
        TS["Task Scheduler & Segment Dispatcher"]
        FA["Federated Weight Aggregator (FedAvg)"]
        Slicer["Graph Slicer & INT4 Quantizer"]
        Budget["TFLOPs Budget Controller"]
    end

    subgraph DataPlane ["Data Plane (FractalAndroid Edge Nodes)"]
        direction TB
        N1["Android Node A (Layers 0-7 / Worker)"]
        N2["Android Node B (Layers 8-15 / Worker)"]
        N3["Android Node C (Layers 16-23 / Worker)"]
        N4["Android Node D (Layers 24-31 / Worker)"]
    end

    subgraph PersistenceLayer ["Persistence & Ledger"]
        FS[("Firestore Ledger (Tokens / Rewards / Nodes)")]
        Disk[("Physical Data Silos (Bins / Checkpoints / PTE Slices)")]
    end

    %% Control Plane Internal Flow
    API --> TM
    TM --> TS
    TS --> Budget
    FA --> Disk
    Slicer --> Disk
    API --> FS

    %% Network Interactions
    N1 & N2 & N3 & N4 <-->|"REST API / TLS (Task Polling & Weight Uploads)"| API
    N1 -->|"INT8 Activation Stream (Wi-Fi Socket)"| N2
    N2 -->|"INT8 Activation Stream (Wi-Fi Socket)"| N3
    N3 -->|"INT8 Activation Stream (Wi-Fi Socket)"| N4

Operational Paradigms

Fractal executes distributed machine learning through two foundational paradigms:

1. Federated Learning (On-Device Training)

In the federated learning lifecycle, raw training datasets are never transferred to the central server. The server partitions data indices into segment bins, dispatches task descriptors to registered Android nodes, and waits for computed checkpoint deltas (.ckpt).

sequenceDiagram
    participant Tenant as Tenant / Administrator
    participant Server as FractalCore Server
    participant Node as FractalAndroid Node
    participant Firestore as Firestore Registry

    Tenant->>Server: Initialize Session (Dataset + TFLOP Budget)
    Server->>Server: Partition Dataset into Binary Segment Bins
    Note over Server: Queue Tasks in Tenant Silo

    Node->>Server: GET /api/task/current (Hardware Telemetry Proof)
    Server-->>Node: ActiveTask (Model URL + Data Bin URL + Hyperparams)

    Node->>Node: Evaluate Telemetry Permit (Battery >= 50%, Thermals <= 40C)
    Node->>Server: Download Model Weights (.tflite) + Binary Bins
    Node->>Node: Execute Local Gradient Descent (TFLite Engine)
    Node->>Server: POST /api/model/upload (Checkpoint Delta .ckpt)

    Server->>Firestore: Credit Liquid MBs to Node Device ID
    Server->>Server: Federated Averaging (FedAvg Summation)
    Server->>Server: Increment Global Model Round

2. Decentralized Pipeline Parallelism (Large Foundation Model Inference)

To execute foundation models (such as Llama 3 8B or TinyLlama) across edge devices without triggering the Android Low Memory Killer (LMK), Fractal Core slices the monolithic model into memory-bounded partitions (layer_[N].pte <= 150MB). Each Android node memory-maps (mmap) an assigned partition and transmits quantized activation tensors across an ad-hoc local mesh.

flowchart LR
    subgraph CoreSlicer ["FractalCore Compiler"]
        M16["Monolithic 16GB FP16 Checkpoint"] --> Ingest["Ingestion & Block Isolation"]
        Ingest --> Quant["INT4 Weight Quantization (torchao)"]
        Quant --> Trace["ATen Dialect Graph Trace (torch.export)"]
        Trace --> Lower["XNNPACK Hardware Delegation"]
        Lower --> Out["32x Mapped Partitions (layer_N.pte <= 150MB)"]
    end

    subgraph EdgeMesh ["Android Compute Mesh"]
        Out -.->|"Deploy Layer Partition"| NodeA["Node A (Input / Layer 0-7)"]
        NodeA -->|"INT8 Activations (<= 4.1KB)"| NodeB["Node B (Layer 8-15)"]
        NodeB -->|"INT8 Activations (<= 4.1KB)"| NodeC["Node C (Layer 16-23)"]
        NodeC -->|"INT8 Activations (<= 4.1KB)"| NodeD["Node D (Output / Layer 24-31)"]
    end

Global System Contracts

The ecosystem maintains strict operational boundaries governed by mathematical contracts:

Contract Target Subsystem Strict Specification Failure Behavior
Weight Contract Model Slicing & Storage Binary partition (.pte / .tflite) strictly $\le$ 150MB Slicer compilation rejected
Activation Contract Pipeline Inter-Node Network 4096-dim INT8 tensor + 1 Float scale strictly $\le$ 4,100 bytes Network frame dropped and re-requested
Telemetry Permit On-Device Execution Gate Battery $\ge$ 50%, Charging == True, Battery Temp $\le$ 40.0 C Training paused immediately
Authentication Contract REST Ingress Gateway X-Auth-Token required for all tenant and administrative routes HTTP 401 / 403 response
Upload Validation Federated Aggregation Gate task_Id must match an active unconsumed dispatch record HTTP 400 Unknown task_Id

Academic Foundations & References

Fractal builds upon foundational research in distributed systems, federated learning, and resource-constrained edge computing. Key works that inform our architectural design include:

Resource-Aware Edge Computing & Adaptive Control

Heterogeneous Model Partitioning & Split Learning

Communication Compression & Quantization

Robust Aggregation & Enterprise Systems

Privacy & Gradient Defense


Repository Topology

The Fractal ecosystem is partitioned across dedicated modular repositories:

.
|-- FractalApp/
|   `-- FractalAndroid/              # Client Application & Compute Node (Kotlin)
|       |-- app/src/main/java/       # Native MVVM Architecture
|       |   |-- AppBackend/          # Telemetry, TFLite Engine, Checkpointing, DAOs
|       |   `-- AppFrontend/         # Telemetry Dashboard, Insights & Settings
|       |-- build.gradle.kts         # Android Build Configuration (Kotlin DSL)
|       `-- docs/                    # Architecture diagrams and specifications
|
|-- FractalCore/                     # Server & Control Plane (Python)
|   |-- src/
|   |   |-- fractal_server/          # Multi-Tenant Flask API & Federated Aggregator
|   |   `-- inference-model-maker/   # Slicer Compiler & Model Partitioning Pipeline
|   |-- scripts/                     # Operational Sweepers, Testers & Reward Audits
|   |-- docs/                        # API schemas, deployment, and security specs
|   |-- Dockerfile                   # Production Container Definition
|   `-- docker-compose.yml           # Multi-Container Orchestration Stack
|
|-- docs/                            # Unified Project Whitepapers & Reports
`-- private.envs/                    # Private Environment Configurations & Service Keys

Getting Started

Prerequisites

Cloning with Submodules

To initialize the entire workspace including all submodule repositories:

git clone --recursive https://github.com/Fractal-Compute-Orchestrations/FractalWorkspace.git

If the repository was cloned without --recursive, initialize submodules manually:

git submodule update --init --recursive

Initializing the Orchestrator and Codec SDK (FractalCore)

# Install the standalone quantization and federated aggregation SDK
pip install -e ./FractalCore

# Verify codec compression fidelity, CLI telemetry, and FedAvg/Krum round
fractal doctor
fractal bench --layers 4 --hidden-size 256
python FractalCore/scripts/quickstart_demo.py

# Run coordinator test suite
pytest FractalCore/tests -v

Initializing the Edge Client (FractalAndroid)

cd FractalApp/FractalAndroid

# Run JVM unit tests (FRQ4/FRQD cross-language wire check, thermal gating, storage safety)
./gradlew testDebugUnitTest

# Build Debug APK
./gradlew assembleDebug

# Install on connected physical device
./gradlew installDebug

Security and Privacy


Governance & Licensing

FRACTAL is engineered, maintained, and owned by Fractal Compute Orchestrations.

FractalWorkspace (Fractal-Compute-Orchestrations/FractalWorkspace)

正在搜索数据库…

这是什么?Fractal 是一个分布式计算生态系统,它利用边缘设备(比如安卓手机)的算力来运行联邦学习和大型基础模型推理,同时把原始用户数据保留在设备本地。
这是一个应用,还是几个独立项目打包在一起?它是一个父工作区仓库,通过 git 子模块整合了两个独立的代码库:FractalCore 是一个 Python 服务器/编排器,FractalAndroid 是一个原生 Kotlin 安卓应用,充当边缘计算节点。
怎样才能把整个工作区跑起来?使用 --recursive 克隆仓库,以拉取所有子模块(或者之后运行子模块初始化命令)。然后按照各自的安装步骤,分别初始化 FractalCore(编排器)和 FractalAndroid(边缘客户端)。
在试用之前,我需要安装什么?服务器端需要 Python 3.10+;构建边缘应用需要 Android Studio 2023.3.1(Jellyfish)或更新版本;要实际进行训练或推理,需要一台真实的安卓设备(API 24+,推荐 ARM64);还需要一个启用了 Firestore 的 Firebase 项目。
在手机上训练会随时运行、耗光电池吗?不会。边缘应用只会在设备充电、电量至少 50%、电池温度低于 40°C 时才进行训练;任一条件不满足,训练会立即暂停。
我的原始训练数据会被发送到服务器吗?不会。Fractal 执行“零数据上传”(Zero Data Ingress)原则:只有编译后的权重检查点会离开设备,原始数据集永远不会离开。
我可以将 Fractal 用于商业用途吗?不可以。Fractal 采用“专有及源码可见、非商业限制性许可证 v3.0”发布,未经作者书面授权,严禁任何商业用途。
Fractal 怎样在单台手机内存都不够的情况下运行 Llama 3 这类大模型?FractalCore 会把模型切分成每块不超过 150MB 的分区(.pte/.tflite)。每个安卓节点只通过内存映射加载分配给自己的那一片,并通过本地临时网状网络,把量化后的 INT8 激活张量转发给下一个节点,因此没有任何一部手机需要容纳完整模型。
服务器如何防止不同用户的数据集和模型混在一起?每个租户在磁盘上都有自己独立的目录树(data/tenants/{username}/),用于存放数据集、bin 文件和检查点,并在存储引擎层面强制隔离,这种机制称为“物理租户沙箱”(Physical Tenant Sandboxing)。
如何防止有人重放旧的检查点上传?每次上传都必须携带一个有效的、仅可使用一次的 taskId,并且该 taskId 要与一条活动的分发记录相关联;过期、失效或重复的 taskId 会在入口处被拒绝。
大小
49.9 MB
星标
9.2K
时长
6个月
提交 · 90 天