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。