请详细写出所有的python代码（含详细的文字注释）

为了帮助您理解，我会提供一个基础的Python代码示例，包括BERT+TextCNN模型的搭建以及基本的数据预处理。这里我们假设已经安装了`transformers`库（包含了Hugging Face的BERT模型），`torch`库（深度学习框架），以及其他必要的库。我们将使用PyTorch实现这个模型。

首先，导入所需的库：

# 导入库
import torch
from torch import nn
from transformers import BertTokenizer, BertModel
from sklearn.model_selection import train_test_split
from collections import Counter

接下来，定义模型类：

class BERTTextCNN(nn.Module):
    def __init__(self, bert_model_name, num_classes, max_len=512):
        super(BERTTextCNN, self).__init__()
        
        # 初始化BERT模型
        self.bert = BertModel.from_pretrained(bert_model_name)
        self.dropout = nn.Dropout(0.2)  # 防止过拟合
        self.pooler = nn.Linear(self.bert.config.hidden_size, num_classes)  # 输出层

        # TextCNN部分
        self.conv1d_layers = nn.ModuleList([
            nn.Conv1d(in_channels=self.bert.config.hidden_size, 
                      out_channels=num_filters, 
                      kernel_size=kernel_size) for kernel_size in [3, 4, 5]
        ])

        self.classifier = nn.Sequential(
            nn.MaxPool1d(max_len),  # 考虑整个句子
            self.dropout,
            nn.Linear(len(self.conv1d_layers) * num_filters, num_classes)  # 统一所有过滤后的维度
        )

    def forward(self, input_ids, attention_mask):
        _, pooled_output = self.bert(input_ids=input_ids, attention_mask=attention_mask)
        pooled_output = self.dropout(pooled_output)

        # 对每个conv层的输出求和，然后扁平化
        conv_outputs = [nn.ReLU()(conv_layer(pooled_output.permute(0, 2, 1))) for conv_layer in self.conv1d_layers]
        conv_outputs = torch.cat(conv_outputs, dim=-1)

        # 取最大池化值，获得句子级别的特征
        max_pool = torch.max(conv_outputs, dim=1)[0]

        # 输出层分类
        return self.classifier(max_pool)

然后，处理数据并定义训练和预测函数：

def preprocess_data(texts, labels, tokenizer, max_len, pad_token_id, label_encoder):
    inputs = tokenizer(texts, truncation=True, padding='max_length', max_length=max_len, return_tensors="pt")
    labels = label_encoder(labels)

    return inputs['input_ids'], inputs['attention_mask'], labels

def train(model, data_loader, optimizer, device, loss_fn):
    model.train()
    total_loss = 0
    for batch in data_loader:
        input_ids, attention_mask, labels = [t.to(device) for t in batch]
        outputs = model(input_ids, attention_mask)
        loss = loss_fn(outputs, labels)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    return total_loss / len(data_loader)

def predict(model, texts, tokenizer, max_len, device):
    with torch.no_grad():
        input_ids, _, _ = preprocess_data(texts, None, tokenizer, max_len, model.config.pad_token_id, None)
        input_ids = input_ids.to(device)
        attention_mask = torch.ones_like(input_ids).to(device)
        probabilities = model(input_ids, attention_mask).softmax(dim=1)
    return probabilities.tolist()

# 数据加载、分割、编码和模型训练略...

以上代码只是一个基础框架，实际应用中还需要细化数据预处理过程（如处理时间特征），划分训练集和验证集，设置损失函数（如交叉熵）、优化器（如Adam），以及训练循环。同时，记得调整超参数以适应您的具体任务需求。