# 📡 **LWM: Large Wireless Model**

**[🚀 Try the Interactive Demo on Hugging Face!](https://huggingface.co/spaces/sadjadalikhani/LWM-Interactive-Demo)**

Welcome to the **LWM** (Large Wireless Model) repository! LWM is a powerful pre-trained model designed to extract rich and high-quality features from wireless communication datasets, such as the **DeepMIMO** dataset. This model leverages advanced neural architectures to efficiently handle wireless channel data, making it applicable in a wide range of tasks like channel prediction, classification, and beamforming. 

LWM was built with robust generalization capabilities, ensuring it performs well even on datasets it hasn’t seen before, making it an ideal tool for both research and real-world applications in wireless communications. Read on to learn how to set up, run, and explore the features of LWM.

---

## ✨ **Key Features**
- **Wireless Channel Embeddings:** LWM is trained to extract meaningful embeddings from wireless channel data, capturing complex features that can be used in various downstream tasks.
- **Flexible Input:** Whether you're working with raw channel data or compressed embeddings, LWM supports different data formats, offering versatility in wireless data processing.
- **Efficient Inference:** LWM's architecture is optimized for quick and scalable inference, providing fast results even on large datasets.
- **Generalization Power:** Tested on several unseen datasets, LWM maintains high-quality performance without overfitting, proving its effectiveness in diverse environments.

---

## 🛠 **How to Use**

### 1. **Install Conda or Mamba**

To begin, install **Conda** or **Mamba** for managing Python environments and packages.

- **Conda:** Download and install [Miniconda](https://docs.conda.io/en/latest/miniconda.html) for a lightweight environment.
- **Mamba (via Miniforge):** [Miniforge](https://github.com/conda-forge/miniforge/releases/latest) is a faster alternative to Conda, with **Mamba** pre-installed for quicker package installations.

---

### 2. **Set Up Your Environment**

#### **Step 1: Create a new environment**

Create a new Python environment named `lwm_env` (or any name you prefer).

```bash
# If you're using Conda:
conda create -n lwm_env python=3.12

# If you're using Mamba:
mamba create -n lwm_env python=3.12
```

#### **Step 2: Activate the environment**

Activate the new environment:

```bash
conda activate lwm_env
```

---

### 3. **Install Required Packages**

Install the necessary Python packages for LWM.

```bash
# Using Conda or Mamba to install PyTorch
conda install pytorch torchvision torchaudio -c pytorch

# Install additional dependencies with pip
pip install -r requirements.txt
```

> **Note**: If `requirements.txt` includes all necessary dependencies, you can install everything in one go by running `pip install -r requirements.txt`.

**Main package requirements include:**
```python
import torch
import numpy as np
import pandas as pd
import DeepMIMOv3
import os
import pickle
import shutil
import warnings
from tqdm import tqdm
from datetime import datetime
from torch.utils.data import Dataset, DataLoader
```

---

### 4. **Clone the Model Repository**

```python
# Step 1: Clone the model repository (if not already cloned)
model_repo_url = "https://huggingface.co/sadjadalikhani/lwm"
model_repo_dir = "./LWM"

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)
```

---

### 5. **Clone the Desired Datasets**

LWM is designed to process datasets from various environments, such as the **DeepMIMO** dataset. Before running inference, ensure the datasets are cloned into your local environment. Below is an overview of some of the available datasets and their respective links:

📊 **Dataset Overview**

| 📊 **Dataset** | 🏙️ **City**         | 👥 **Number of Users** | 🔗 **DeepMIMO Page**                                                                                       |
|----------------|----------------------|------------------------|------------------------------------------------------------------------------------------------------------|
| Dataset 0      | 🌆 Denver             | 1354                   | [DeepMIMO City Scenario 18](https://www.deepmimo.net/scenarios/deepmimo-city-scenario18/)                   |
| Dataset 1      | 🏙️ Indianapolis       | 3248                   | [DeepMIMO City Scenario 15](https://www.deepmimo.net/scenarios/deepmimo-city-scenario15/)                   |

```python
# Function to clone specific dataset scenario
def clone_dataset_scenario(scenario_name, repo_url, model_repo_dir="./LWM", scenarios_dir="scenarios"):
    # Logic for cloning datasets
    pass
```

---

### 6. **Tokenize and Load the Model**

Once you have cloned the model and the datasets, you can preprocess the data and load the model.

```python
from input_preprocess import tokenizer
from lwm_model import lwm

# Tokenizing the dataset
preprocessed_chs = tokenizer(selected_scenario_names=["city_18_denver"], manual_data=None, gen_raw=True)

# Load LWM model
device = 'cuda' if torch.cuda.is_available() else 'cpu'
print(f"Loading the LWM model on {device}...")
model = lwm.from_pretrained(device=device)
```

---

### 7. **Perform Inference**

After tokenizing the data and loading the model, you're ready to perform inference with LWM.

```python
from inference import lwm_inference, create_raw_dataset

input_types = ['cls_emb', 'channel_emb', 'raw']
selected_input_type = 'cls_emb'  # Choose the type of input

if selected_input_type in ['cls_emb', 'channel_emb']:
    dataset = lwm_inference(preprocessed_chs, selected_input_type, model, device)
else:
    dataset = create_raw_dataset(preprocessed_chs, device)
```

---

### LWM Architecture and Usage in Wireless Tasks

**LWM** employs a robust neural network architecture to extract valuable features from wireless channel data. Its deep layers, combined with advanced tokenization, make it suitable for challenging wireless communication tasks, such as beamforming, interference management, and channel state prediction.

LWM is particularly effective in generalizing across diverse environments without overfitting, and its results are consistent across raw channel data and embeddings.

By using **LWM**, you can enhance your wireless communication systems by utilizing data-driven models that outperform traditional approaches, offering faster and more accurate results.