基于半监督学习的 AI 定位模型：使用 RSRP 数据进行二维坐标预测

以下是您描述的半监督学习模型的代码，包括训练和预测过程：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
import numpy as np

# 设置随机种子，以便结果可重现
torch.manual_seed(42)
np.random.seed(42)

# 定义自动编码器的网络结构
class Autoencoder(nn.Module):
    def __init__(self, input_dim, hidden_dim):
        super(Autoencoder, self).__init__()
        self.encoder = nn.Linear(input_dim, hidden_dim)
        self.decoder = nn.Linear(hidden_dim, input_dim)

    def forward(self, x):
        encoded = self.encoder(x)
        decoded = self.decoder(encoded)
        return encoded, decoded

# 设置超参数
input_dim = 18  # 输入维度
hidden_dim = 2   # 隐层维度
batch_size = 10
learning_rate = 0.001
num_epochs = 100
labeled_data_size = 100
unlabeled_data_size = 1000

# 生成随机数据
labeled_data = torch.randn(labeled_data_size, input_dim)
labeled_labels = torch.randn(labeled_data_size, 2)
unlabeled_data = torch.randn(unlabeled_data_size, input_dim)

# 创建数据集和数据加载器
labeled_dataset = TensorDataset(labeled_data, labeled_labels)
unlabeled_dataset = TensorDataset(unlabeled_data)
labeled_dataloader = DataLoader(labeled_dataset, batch_size=batch_size, shuffle=True)
unlabeled_dataloader = DataLoader(unlabeled_dataset, batch_size=batch_size, shuffle=True)

# 创建编码器和解码器模型实例
encoder_model = Autoencoder(input_dim, hidden_dim)
decoder_model = Autoencoder(hidden_dim, input_dim)

# 定义损失函数和优化器
criterion = nn.MSELoss()
encoder_optimizer = optim.Adam(encoder_model.parameters(), lr=learning_rate)
decoder_optimizer = optim.Adam(decoder_model.parameters(), lr=learning_rate)

# 训练模型
for epoch in range(num_epochs):
    total_loss = 0.0
    for labeled_batch, unlabeled_batch in zip(labeled_dataloader, unlabeled_dataloader):
        labeled_inputs, labeled_labels = labeled_batch
        unlabeled_inputs, _ = unlabeled_batch

        # 训练编码器
encoder_optimizer.zero_grad()

        labeled_encoded, _ = encoder_model(labeled_inputs)
unlabeled_encoded, _ = encoder_model(unlabeled_inputs)

        labeled_encoder_loss = criterion(labeled_encoded, labeled_labels)
unlabeled_encoder_loss = criterion(unlabeled_encoded, torch.zeros_like(unlabeled_encoded))

        encoder_loss = labeled_encoder_loss + unlabeled_encoder_loss

        encoder_loss.backward()
encoder_optimizer.step()

        # 训练解码器
decoder_optimizer.zero_grad()

        labeled_encoded, _ = encoder_model(labeled_inputs)
unlabeled_encoded, _ = encoder_model(unlabeled_inputs)

        labeled_decoded = decoder_model(labeled_encoded)[1]
unlabeled_decoded = decoder_model(unlabeled_encoded)[1]

        labeled_decoder_loss = criterion(labeled_decoded, labeled_inputs)
unlabeled_decoder_loss = criterion(unlabeled_decoded, unlabeled_inputs)

        decoder_loss = labeled_decoder_loss + unlabeled_decoder_loss

        decoder_loss.backward()
decoder_optimizer.step()

        total_loss += encoder_loss.item() + decoder_loss.item()

    print(f'Epoch {epoch+1}/{num_epochs}, Loss: {total_loss}')

# 使用训练好的编码器进行预测
test_data = torch.randn(10, input_dim)  # 测试数据
with torch.no_grad():
    encoded, _ = encoder_model(test_data)
    # 对输出结果进行处理或评估

在上述代码中，我们首先定义了自动编码器的网络结构，并设置了超参数。然后，我们随机生成了有标签数据和无标签数据，并使用它们创建了数据集和数据加载器。在训练模型的过程中，我们循环遍历有标签数据和无标签数据的数据加载器，并计算并累加编码器和解码器的损失。最后，我们使用训练好的编码器对测试数据进行预测。

请注意，上述示例中的数据是随机生成的示例数据，您需要将其替换为您自己的数据。此外，您可能需要根据实际情况调整超参数和模型结构。

希望这个例程对您有所帮助！如果还有其他问题，请随时提问。