Lwm V1.1

🚀 LWM 1.1

LWM 1.1是一个用于无线信道特征提取的预训练模型。它在LWM 1.0的基础上进行了更新，提升了可扩展性、泛化能力和效率，能适应不同的信道配置。该模型在更广泛的数据集上进行预训练，可学习模拟和真实世界无线信道的结构化表示。

🚀 快速开始

你可以通过以下链接体验相关内容：

• 🚀 点击此处尝试基于LWM 1.0的交互式演示！
• 🚀 点击此处尝试Colab笔记本！

✨ 主要特性

模型设计

• 架构基础：基于Transformer架构，用于建模无线信道数据中的空间和频率依赖关系。
• 预训练方法：采用增强的掩码信道建模（Masked Channel Modeling，MCM）预训练方法，提高特征学习和泛化能力。
• 二维补丁分割：引入2D补丁分割，联合处理空间（天线）和频率（子载波）关系，提供更结构化的信道表示。
• 批量处理：使用基于桶的批量处理（bucket-based batching），高效处理可变大小的输入，确保内存高效的训练和推理。

功能优势

• 通用特征提取器：可用于无线通信和感知任务，在多样化数据集上预训练，能有效捕捉不同环境下的信道特征。
• 灵活性增强：支持多种(N, SC)配置，去除固定信道大小限制，增加序列长度至512，可高效处理更大的输入维度。
• 特征提取优化：通过先进的预训练和增加模型容量，改进特征提取，生成更优质的嵌入表示。
• 泛化能力提升：在更大、更多样化的数据集上训练，能在不同环境下可靠运行。
• 任务适应性强：支持微调，可无缝集成到各种应用中。

应用示例

在LoS/NLoS分类任务中，使用基于LWM的高度紧凑CLS嵌入和高维信道嵌入，相比原始信道具有明显优势。

图： 该图展示了使用无线信道及其LWM嵌入训练的模型在LoS/NLoS分类中的F1分数比较。

📦 安装指南

1. 安装Conda

首先，确保安装了像Conda这样的包管理器，用于管理Python环境和包。你可以通过Anaconda或Miniconda安装Conda：

• Anaconda：包含全面的科学包套件，点击此处下载。
• Miniconda：轻量级版本，仅包含Conda和Python，点击此处下载。

安装完成后，即可使用Conda管理环境。

2. 创建新环境

安装Conda后，按以下步骤创建新环境并安装所需包：

步骤1：创建新环境

打开Anaconda PowerShell Prompt，创建名为lwm_env的新Conda环境：

conda create -n lwm_env

步骤2：激活环境

激活环境：

conda activate lwm_env

3. 安装所需包

激活环境后，安装必要的包：

安装支持CUDA的PyTorch

虽然推理可以在CPU上高效运行，但训练一些资源密集型的下游任务可能需要GPU。访问此页面，根据系统规格选择合适的选项，网站将生成定制的安装命令。

例如，在NVIDIA系统上，可使用以下命令安装支持指定CUDA版本的PyTorch：

conda install pytorch torchvision torchaudio pytorch-cuda=12.1 -c pytorch -c nvidia

请确保指定的CUDA版本与系统兼容，必要时进行调整。

⚠️ 重要提示

如果在安装支持CUDA的PyTorch时遇到问题，请验证CUDA版本兼容性，也可能是由于冲突的安装尝试导致的，可尝试创建新环境。

通过Conda Forge安装其他所需包

conda install python numpy pandas matplotlib tqdm -c conda-forge

使用pip安装DeepMIMOv3

pip install DeepMIMOv3

4. 克隆数据集场景

以下函数可帮助你从仓库中克隆特定的数据集场景：

import subprocess
import os

# 函数用于克隆特定的数据集场景文件夹
def clone_dataset_scenario(scenario_name, repo_url, model_repo_dir="./LWM", scenarios_dir="scenarios"):
    current_dir = os.path.basename(os.getcwd())
    if current_dir == "LWM":
        model_repo_dir = "."

    # 创建场景目录（如果不存在）
    scenarios_path = os.path.join(model_repo_dir, scenarios_dir)
    if not os.path.exists(scenarios_path):
        os.makedirs(scenarios_path)

    scenario_path = os.path.join(scenarios_path, scenario_name)

    # 初始化数据集仓库的稀疏检出
    if not os.path.exists(os.path.join(scenarios_path, ".git")):
        print(f"Initializing sparse checkout in {scenarios_path}...")
        subprocess.run(["git", "clone", "--sparse", repo_url, "."], cwd=scenarios_path, check=True)
        subprocess.run(["git", "sparse-checkout", "init", "--cone"], cwd=scenarios_path, check=True)
        subprocess.run(["git", "lfs", "install"], cwd=scenarios_path, check=True)  # 必要时安装Git LFS

    # 将请求的场景文件夹添加到稀疏检出
    print(f"Adding {scenario_name} to sparse checkout...")
    subprocess.run(["git", "sparse-checkout", "add", scenario_name], cwd=scenarios_path, check=True)
    
    # 必要时拉取大文件（使用Git LFS）
    subprocess.run(["git", "lfs", "pull"], cwd=scenarios_path, check=True)

    print(f"Successfully cloned {scenario_name} into {scenarios_path}.")

def clone_dataset_scenarios(selected_scenario_names, dataset_repo_url, model_repo_dir):
    for scenario_name in selected_scenario_names:
        clone_dataset_scenario(scenario_name, dataset_repo_url, model_repo_dir)

5. 克隆模型仓库

将LWM-v1.1模型仓库克隆到本地系统：

# 步骤1：克隆模型仓库（如果尚未克隆）
model_repo_url = "https://huggingface.co/wi-lab/lwm-v1.1"
model_repo_dir = "./LWM-v1.1"

if not os.path.exists(model_repo_dir):
    print(f"Cloning model repository from {model_repo_url}...")
    subprocess.run(["git", "clone", model_repo_url, model_repo_dir], check=True)

6. 克隆所需的数据集场景

你可以从DeepMIMO数据集中克隆特定场景，具体信息如下表所示：

📊 数据集概述

📊 数据集	🏙️ 城市	👥 用户数量	🔗 DeepMIMO页面
数据集0	🌆 丹佛	1354	DeepMIMO城市场景18
数据集1	🏙️ 印第安纳波利斯	3248	DeepMIMO城市场景15
数据集2	🌇 俄克拉荷马	3455	DeepMIMO城市场景19
数据集3	🌆 沃思堡	1902	DeepMIMO城市场景12
数据集4	🌉 圣克拉拉	2689	DeepMIMO城市场景11
数据集5	🌅 圣地亚哥	2192	DeepMIMO城市场景7

需要注意的是，这六个数据集在LWM模型的预训练过程中未被使用，模型生成的高质量嵌入证明了其强大的泛化能力，而非过拟合。

如果你计划使用自定义数据集，请确保复杂信道最多包含8196个元素（N * SC <= 8196）。在LWM-v1.0中，输入仅限于大小为(N, SC) = (32, 32)的复杂信道，而LWM-v1.1现在可以处理任意大小的复杂信道，为你的特定用例提供了更大的灵活性！😊

克隆场景：

import numpy as np
dataset_repo_url = "https://huggingface.co/datasets/wi-lab/lwm"  # 数据集仓库的基础URL
scenario_names = np.array(["city_6_miami"])

scenario_idxs = np.array([0])  # 选择场景索引
selected_scenario_names = scenario_names[scenario_idxs]

# 克隆请求的场景
clone_dataset_scenarios(selected_scenario_names, dataset_repo_url, model_repo_dir)

7. 将工作目录更改为LWM

在继续之前，请确保你位于LWM仓库的正确工作目录中：

import os

if os.path.exists(model_repo_dir):
    os.chdir(model_repo_dir)
    print(f"Changed working directory to {os.getcwd()}")
else:
    print(f"Directory {model_repo_dir} does not exist. Please check if the repository is cloned properly.")

这确保所有路径和依赖项与仓库结构一致。

💻 使用示例

基础用法

接下来，我们将分别介绍LWM-v1.1的推理和下游任务，以及预训练过程。

推理和下游任务

# 加载所需的包和模块
from input_preprocess import tokenizer, scenarios_list
from inference import lwm_inference
from utils import prepare_loaders
from train import finetune
import lwm_model
import matplotlib.pyplot as plt
import numpy as np
import torch
import torch.nn as nn
import warnings

warnings.filterwarnings("ignore", category=UserWarning)

# 设置下游任务的参数
n_beams = 16
task = ['Beam Prediction', 'LoS/NLoS Classification'][1]  # 默认：LoS/NLoS分类
task_type = ["classification", "regression"][0]  # 默认：分类
visualization_method = ["pca", "umap", "tsne"][2]  # 默认：TSNE
input_types = ["cls_emb", "channel_emb", "raw"]  # 支持的输入类型
train_ratios = [.001, .01, .05, .1, .25, .5, .8]  # 训练数据的比例
fine_tuning_status = [None, ["layers.8", "layers.9", "layers.10", "layers.11"], "full"]  # 微调配置
selected_scenario_names = [scenarios_list()[6]]  # 选择特定场景

# 预处理
preprocessed_data, labels, raw_chs = tokenizer(
    selected_scenario_names, 
    bs_idxs=[3], 
    load_data=False, 
    task=task, 
    n_beams=n_beams
)

# 加载预训练的LWM-v1.1模型
from lwm_model import lwm  # 根据需要调整导入路径

gpu_ids = [0]
device = torch.device(f"cuda:{gpu_ids[0]}" if torch.cuda.is_available() else "cpu")

# 初始化模型
model = lwm().to(device)

# 加载预训练的模型状态
model_name = "model.pth"
state_dict_path = f"models/{model_name}"
state_dict = torch.load(state_dict_path, map_location=device)

# 清理状态字典以兼容DataParallel
clean_state_dict = {k.replace("module.", ""): v for k, v in state_dict.items()}
model.load_state_dict(clean_state_dict)

# 如果指定，使用多个GPU
if len(gpu_ids) > 1:
    model = nn.DataParallel(model, device_ids=gpu_ids)

print(f"Model loaded successfully on device: {device}")

# 可视化原始信道和嵌入空间
chs = lwm_inference(
    model, 
    preprocessed_data, 
    input_type="cls_emb", 
    device=device, 
    batch_size=64, 
    visualization=True, 
    labels=labels, 
    visualization_method=visualization_method
)

# 微调预训练模型
results = np.zeros((len(fine_tuning_status), len(input_types), len(train_ratios)))

for fine_tuning_stat_idx, fine_tuning_stat in enumerate(fine_tuning_status):
    for input_type_idx, input_type in enumerate(input_types):
        
        if input_type == "raw" and fine_tuning_stat is not None:
            continue
        
        selected_patches_idxs = None
        for train_ratio_idx, train_ratio in enumerate(train_ratios):
            print(f"\nfine-tuning status: {fine_tuning_stat}")
            print(f"input type: {input_type}")
            print(f"train ratio: {train_ratio}\n")
            
            # 准备数据加载器
            train_loader, val_loader, samples, target = prepare_loaders(
                preprocessed_data=preprocessed_data,
                labels=labels,
                selected_patches_idxs=selected_patches_idxs,
                input_type=input_type,
                task_type=task_type,
                train_ratio=train_ratio,
                batch_size=128,
                seed=42
            )
            
            # 微调LWM
            fine_tuned_model, best_model_path, train_losses, val_losses, f1_scores, attn_maps_ft = finetune(
                base_model=model, 
                train_loader=train_loader,
                val_loader=val_loader,
                task_type=task_type,
                input_type=input_type,
                num_classes=n_beams if task == 'Beam Prediction' else 2 if task == 'LoS/NLoS Classification' else None,
                output_dim=target.shape[-1] if task_type == 'regression' else None,
                use_custom_head=True,
                fine_tune_layers=fine_tuning_stat,
                optimizer_config={"lr": 1e-3},
                epochs=15,
                device=device,
                task=task
            )
            
            results[fine_tuning_stat_idx][input_type_idx][train_ratio_idx] = f1_scores[-1]

# 可视化微调结果
markers = ['o', 's', 'D']
labels = ['CLS Emb', 'CHS Emb', 'Raw']
fine_tuning_status_labels = ['No FT', 'Partial FT', 'Full FT']
line_styles = ['-', '--', ':']
colors = plt.cm.viridis(np.linspace(0, 0.8, len(labels)))

plt.figure(figsize=(12, 8), dpi=500)
for ft_idx, (ft_status_label, line_style) in enumerate(zip(fine_tuning_status_labels, line_styles)):
    for idx, (marker, label, color) in enumerate(zip(markers, labels, colors)):
        if label == "Raw" and ft_status_label != "No FT":
            continue
        plt.plot(
            train_ratios, 
            results[ft_idx, idx], 
            marker=marker, 
            linestyle=line_style, 
            label=f"{label} ({ft_status_label})", 
            color=color, 
            linewidth=3, 
            markersize=9
        )
plt.xscale('log')
plt.xlabel("Train Ratio", fontsize=20)
plt.ylabel("F1-Score", fontsize=20)
plt.legend(fontsize=17, loc="best")
plt.grid(True, linestyle="--", alpha=0.7)
plt.xticks(fontsize=17)
plt.yticks(fontsize=17)
plt.tight_layout()
plt.show()

# 比较原始信道空间和微调后的嵌入空间
chs = lwm_inference(
    fine_tuned_model.model, 
    preprocessed_data, 
    input_type="cls_emb", 
    device=device, 
    batch_size=64, 
    visualization=False, 
    labels=labels, 
    visualization_method=visualization_method
)

预训练LWM-v1.1

# 加载所需的包和模块
import torch
import torch.nn as nn
from torch.utils.data import random_split
from input_preprocess import tokenizer, scenarios_list
from utils import create_dataloader, count_parameters
import numpy as np
import lwm_model
from torch.optim.lr_scheduler import CosineAnnealingLR, LambdaLR
from torch.optim import AdamW
from train import train_lwm
import warnings

warnings.filterwarnings("ignore", category=UserWarning)

# 设置预训练的关键超参数
EPOCHS = 50
BATCH_SIZE = 128 
VAL_BATCH_SIZE = 64 
WARMUP_EPOCHS = 5
BASE_LR = 5e-4
N_ROWS = 4
N_COLUMNS = 4
ELEMENT_LENGTH = N_ROWS * N_COLUMNS * 2
D_MODEL = 128 
MAX_LEN = 513
N_LAYERS = 12 
WEIGHT_DECAY = 0.05
BETA1 = 0.9
BETA2 = 0.999
MASK_PERCENT = 0.40
N_HEADS = 8
DROPOUT = 0.1

# 生成数据集
bs_idxs = [1, 2, 3] 
selected_scenario_names = scenarios_list()[:80] 
preprocessed_data = tokenizer(
    selected_scenario_names, 
    MAX_LEN, 
    masking_percent=MASK_PERCENT, 
    mask=True, 
    seed=42
)

# 分割数据集
SEED = 42
torch.manual_seed(SEED)
np.random.seed(SEED)
train_ratio = 0.8
val_ratio = 0.2
train_data = {}
val_data = {}
test_data = {}

for key, samples in preprocessed_data.items():
    total_samples = len(samples)
    train_size = int(train_ratio * total_samples)
    val_size = int(val_ratio * total_samples)
    test_size = total_samples - train_size - val_size
    
    train_data[key], val_data[key], test_data[key] = random_split(
        samples, [train_size, val_size, test_size]
    )

train_loaders = create_dataloader(train_data, batch_size=BATCH_SIZE, shuffle=True)
val_loaders = create_dataloader(val_data, batch_size=VAL_BATCH_SIZE, shuffle=False)

# 初始化模型
load_model = True
gpu_ids = [0]
device = torch.device("cuda:0")
model = lwm_model.lwm().to(device)

if load_model:
    model_name = "model.pth"
    state_dict = torch.load(f"models/{model_name}", map_location=device)
    new_state_dict = {k.replace("module.", ""): v for k, v in state_dict.items()}
    model.load_state_dict(new_state_dict)

model = nn.DataParallel(model, gpu_ids)
print(f"Model loaded successfully on GPU {device.index}")
n_parameters = count_parameters(model)
print(f"Number of trainable parameters: {n_parameters:,}")

# 定义优化器和学习率调度器
optimizer = AdamW(
    model.parameters(),
    lr=BASE_LR,
    betas=(BETA1, BETA2),
    weight_decay=WEIGHT_DECAY
)

def lr_lambda(current_step):
    if current_step < WARMUP_STEPS:
        return current_step / WARMUP_STEPS
    else:
        scaled_progress = (current_step - WARMUP_STEPS) / (TOTAL_STEPS - WARMUP_STEPS)
        cosine_decay = 0.5 * (1 + np.cos(np.pi * scaled_progress))
        return cosine_decay * (BASE_LR - MIN_LR) / BASE_LR + MIN_LR / BASE_LR

scheduler = LambdaLR(optimizer, lr_lambda=lr_lambda)

# 训练模型
pretrained_model = train_lwm(
    model,
    train_loaders,
    val_loaders,
    optimizer,
    scheduler,
    EPOCHS,
    device=device
)

📚 详细文档

关键改进

输入灵活性扩展

• 去除固定信道大小限制：支持多种(N, SC)配置，不再局限于(32, 32)。
• 增加序列长度：从128扩展到512，可高效处理更大的输入维度。

数据集和预训练增强

• 数据集覆盖范围更广：训练场景从15个增加到140个，提高跨环境的泛化能力。
• MCM中更高的掩码比例：从15%增加到40%，使掩码信道建模（MCM）任务更具挑战性，有效提升特征提取能力。
• 更大的预训练数据集：样本数量从820K扩展到1.05M，实现更强大的表示学习。

模型架构改进

• 模型容量增加：参数数量从600K扩展到2.5M，增强表示能力。
• 二维补丁分割：补丁现在跨越天线和子载波，改善空间 - 频率特征学习。

训练和效率优化

• 自适应学习率调度：采用AdamW优化器和余弦衰减（Cosine Decay），提高收敛稳定性。
• 计算效率提升：每层的注意力头数量从12个减少到8个，在平衡计算成本的同时保持特征提取能力。

版本比较

特性	LWM 1.0	LWM 1.1
信道大小限制	固定为(32, 32)	支持多种(N, SC)对
序列长度支持	128（16维）	512（32维）
预训练样本	820K	1.05M
预训练场景	15个	140个
掩码比例	15%	40%
嵌入大小	64	128
参数数量	600K	2.5M
分割方式	一维	二维

详细更改说明

无信道大小限制

LWM 1.0在单一的(N, SC) = (32, 32)对上进行预训练，限制了其对其他信道配置的泛化能力。LWM 1.1在20种不同的(N, SC)对上进行预训练，从较小的设置（如(8, 32)）到更复杂的设置（如(128, 64)），能够有效处理各种信道配置，确保在不发生过拟合的情况下实现强大的泛化能力。

为了高效处理可变大小的输入，采用了基于桶的批量处理方法，将大小相似的输入分组在一起，避免了传统批量处理中常见的过度填充问题，既节省了内存，又提高了训练时的计算效率。此外，验证样本从每个桶中抽取20%，确保在所有输入大小上进行平衡的评估过程。

更大、更多样化的预训练数据集

泛化能力是基础模型的关键方面。LWM 1.1显著扩展了训练数据集，涵盖更多样化的场景和环境。添加了七个新的城市场景（夏洛特、丹佛、俄克拉荷马、印第安纳波利斯、沃思堡、圣克拉拉和圣地亚哥），丰富了模型对各种城市布局的接触。为了提高训练数据的空间分辨率，将DeepMIMO城市场景中用户位置之间的网格间距从2.5米减小到1米，导致用户位置密度更高。这一调整需要对所有场景重新进行射线追踪，以生成高分辨率的无线信道数据。

此外，在每个场景中引入了来自多个基站的信道，具有不同的(N, SC)对，确保模型遇到广泛的信道特征。这一扩展总共产生了130万个预训练样本，其中20%用于验证。这种多样性反映了现实世界部署中的可变性，如城市、郊区和农村环境。通过让LWM 1.1接触这种多样性，模型获得了在具有不同传播特征的环境中进行泛化的能力，使其更加可靠和通用。

如需查看完整的预训练场景列表和规格，请访问：LWM 1.1训练场景

针对特定任务的嵌入生成进行微调

虽然预训练提供了强大的特征提取器，但下游任务通常需要定制的嵌入。在LWM 1.1中，引入了微调选项，使用户能够根据特定任务自定义模型。用户现在可以冻结模型的特定层，允许其余层适应特定任务的要求。这一功能对于容易过拟合的任务（如LoS/NLoS分类）特别有价值，在这些任务中，对所有层进行过度训练可能导致泛化性能不佳。

为了进一步简化特定任务的适应过程，为下游任务提供了默认的分类和回归头。用户还可以定义自己的自定义头，以满足独特的要求，确保最大的灵活性和适应性。

增加模型容量

LWM 1.1通过将嵌入大小从64增加到128，显著增强了模型提取复杂特征的能力。这一增加使模型的参数数量增加了四倍多，从600K增加到2.5M。更大的嵌入大小使模型能够在信道数据中表示更复杂的关系，提高其在具有挑战性的任务（如波束预测和信道估计）上的性能。

这一变化直接影响了嵌入的质量，使其在各种下游任务中更加表达性和鲁棒性，即使在标记数据有限的情况下也是如此。

具有更高掩码比例的挑战性MCM任务

掩码信道建模（MCM）任务是LWM预训练方法的核心。在LWM 1.1中，通过将掩码比例从15%增加到40%，使任务更具挑战性。这意味着在训练期间，更大比例的信道数据被掩码，要求模型从上下文依赖关系中推断缺失的信息。

这一增强迫使模型依赖天线和子载波之间更深层次的空间关系，而不是学习表面模式。因此，LWM 1.1生成的嵌入更加鲁棒，更能处理具有不完整或嘈杂数据的现实世界场景。

支持更大的输入大小

无线通信系统越来越多地处理具有更高维度的更大信道。为了满足这些需求，在LWM 1.1中，将最大序列长度从128增加到512。这一变化使模型能够处理更大、更详细的信道数据，而无需修改，拓宽了其在高维无线任务中的适用性。这确保了LWM-v1.1在无线系统的规模和复杂性不断增长的情况下仍然相关。

用于现实学习的二维补丁分割

在LWM 1.0中，补丁是基于单一维度进行分割的，通常将同一天线内不同子载波的元素分组在一起。在LWM 1.1中，引入了二维补丁分割，其中补丁现在结合了来自天线和子载波的元素。这更准确地反映了现实世界的无线信道依赖关系，因为天线和子载波之间的关系在实际部署中至关重要。

这种多维分割增加了MCM任务的复杂性，要求模型学习数据中更深层次和更有意义的依赖关系。通过更好地使训练方法与现实世界条件保持一致，LWM 1.1进一步增强了其在实际场景中的泛化和执行能力。

优化的训练策略

训练大型模型需要精心设计的优化技术，以确保平稳收敛和泛化。在LWM 1.1中，采用了AdamW优化器，与传统的Adam相比，它改进了权重正则化，防止过拟合。学习率调度也得到了改进，包括一个5步的预热阶段，然后是余弦衰减。这一策略确保模型从初始训练阶段平稳过渡到收敛，保持稳定性并提高整体性能。

提高计算效率

为了在计算效率和性能之间取得平衡，在LWM 1.1中，将每层的注意力头数量从12个减少到8个。这一减少降低了训练和推理期间的计算负载，使模型更加高效，而不会显著影响其提取有意义特征的能力。精简的架构确保LWM 1.1不仅强大，而且适用于资源受限的环境。

为什么需要这些更改

LWM 1.1的更新是由无线通信任务对更大灵活性、可扩展性和性能的现实需求驱动的。去除信道大小限制和使数据集多样化解决了无线环境中固有的可变性。增加模型容量和增强MCM任务提高了嵌入的质量，而优化的训练策略和计算效率使模型适用于广泛的应用。这些更改使LWM 1.1向前迈出了重要一步，确保其在推进无线通信研究中的相关性和影响力。

🔧 技术细节

模型架构

基于Transformer架构，利用多头自注意力机制捕捉无线信道数据中的长距离依赖关系。通过堆叠多个Transformer层，学习到信道数据的层次化表示。

预训练方法

采用掩码信道建模（MCM）方法，在训练过程中随机掩码部分信道数据，让模型预测这些掩码部分，从而学习到信道的潜在结构和特征。

数据处理

• 二维补丁分割：将信道数据分割成二维补丁，同时考虑天线和子载波的信息，提高特征提取的有效性。
• 基于桶的批量处理：根据输入数据的大小将其分组到不同的桶中，减少填充操作，提高内存使用效率。

训练优化

• AdamW优化器：结合Adam优化器和权重衰减，防止过拟合，提高模型的泛化能力。
• 学习率调度：采用线性预热和余弦衰减的学习率调度策略，确保训练过程的稳定性和收敛速度。

📄 许可证

如果你使用LWM模型或其任何修改部分，请引用以下论文：

@misc{alikhani2024largewirelessmodellwm,
      title={Large Wireless Model (LWM): A Foundation Model for Wireless Channels}, 
      author={Sadjad Alikhani and Gouranga Charan and Ahmed Alkhateeb},
      year={2024},
      eprint={2411.08872},
      archivePrefix={arXiv},
      primaryClass={cs.IT},
      url={https://arxiv.org/abs/2411.08872}, 
}

探索交互式演示

通过我们的Hugging Face Spaces演示交互式体验LWM：尝试交互式演示！

现在你可以开始探索LWM在无线通信中的强大功能了！开始处理数据集并生成高质量的嵌入，推动你的研究或应用发展。

如果你有任何问题或需要帮助，请随时：

• 访问Hugging Face讨论区获取社区支持。
• 查看LWM网站常见问题解答。
• 通过电子邮件直接联系我们：lwmwireless@gmail.com。