NameError: name 'max_pol_id' is not defined

import random
import math
class PolModel(paddle.nn.Layer):
    def __init__(self, use_poster, use_pol_title, use_pol_cat, 
                  use_age_job,fc_sizes, max_pol_id, 
                  policy_cat, policy_title):
        super(PolModel, self).__init__()
                
        # 将传入的name信息和bool型参数添加到模型类中
        self.use_pol_poster = use_poster
        self.use_pol_title = use_pol_title
        self.use_usr_age_job = use_age_job
        self.use_pol_cat = use_pol_cat
        self.fc_sizes = fc_sizes
        self.max_pol_id = max_pol_id
        self.policy_cat = policy_cat
        self.policy_title = policy_title

        """ define network layer for embedding policy info """
        # 对政策ID信息做映射，并紧接着一个Linear层
        POL_DICT_SIZE =self.max_pol_id + 1
        self.pol_emb = Embedding(num_embeddings=POL_DICT_SIZE, embedding_dim=16)
        self.pol_fc = Linear(16, 16)
        
        # 对政策类别做映射
        POL_CATEGORY_DICT_SIZE = len(policy_cat) + 1
        self.pol_cat_emb = Embedding(num_embeddings=POL_CATEGORY_DICT_SIZE, embedding_dim=16)
        self.pol_cat_fc = Linear(16, 16)
        
        # 对政策名称做映射
        POL_TITLE_DICT_SIZE = len(policy_title) + 1
        self.pol_title_emb = Embedding(num_embeddings=POL_TITLE_DICT_SIZE, embedding_dim=32)
        self.pol_title_conv = Conv2D(in_channels=1, out_channels=1, kernel_size=(3, 1), stride=(2,1), padding=0)
        self.pol_title_conv2 = Conv2D(in_channels=1, out_channels=1, kernel_size=(3, 1), stride=1, padding=0)

        # 新建一个Linear层，用于整合政策特征
        self.pol_concat_embed = Linear(in_features=64, out_features=256)
        
        #政策特征和用户特征使用了不同的全连接层，不共享参数
        policy_sizes = [256] + self.fc_sizes
        acts = ["relu" for _ in range(len(self.fc_sizes))]
        self._policy_layers = []
        for i in range(len(self.fc_sizes)):
            linear = paddle.nn.Linear(
                in_features=policy_sizes[i],
                out_features=policy_sizes[i + 1],
                weight_attr=paddle.ParamAttr(
                    initializer=paddle.nn.initializer.Normal(
                        std=1.0 / math.sqrt(policy_sizes[i]))))
            self.add_sublayer('linear_policy_%d' % i, linear)
            self._policy_layers.append(linear)
            if acts[i] == 'relu':
                act = paddle.nn.ReLU()
                self.add_sublayer('policy_act_%d' % i, act)
                self._policy_layers.append(act)

    # 定义政策特征的前向计算过程
    def get_pol_feat(self, pol_var):
        """ get policy features"""
        # 获得电影数据
        pol_id, pol_cat, pol_title, pol_poster = pol_var
        feats_collect = []
        # 获得batchsize的大小
        batch_size = pol_id.shape[0]
        # 计算政策ID的特征，并存在feats_collect中
        pol_id = self.pol_emb(pol_id)
        pol_id = self.pol_fc(pol_id)
        pol_id = F.relu(pol_id)
        feats_collect.append(pol_id)
        
        # 如果使用政策主体的种类数据，计算政策种类特征的映射
        if self.use_pol_cat:
            # 计算政策主体种类的特征映射，对多个种类的特征求和得到最终特征
            pol_cat = self.pol_cat_emb(pol_cat)
            pol_cat = paddle.sum(pol_cat, axis=1, keepdim=False)

            pol_cat = self.pol_cat_fc(pol_cat)
            feats_collect.append(pol_cat)

        if self.use_pol_title:
            # 计算政策名字的特征映射，对特征映射使用卷积计算最终的特征
            pol_title = self.pol_title_emb(pol_title)
            pol_title = F.relu(self.pol_title_conv2(F.relu(self.pol_title_conv(pol_title))))
            
            pol_title = paddle.sum(pol_title, axis=2, keepdim=False)
            pol_title = F.relu(pol_title)
            pol_title = paddle.reshape(pol_title, [batch_size, -1])
            feats_collect.append(pol_title)
            
        # 使用一个全连接层，整合所有政策特征，映射为一个256维的特征向量
        pol_feat = paddle.concat(feats_collect, axis=-1)
        pol_features = F.tanh(self.pol_concat_embed(pol_feat))
        for n_layer in self._policy_layers:
            pol_features = n_layer(pol_features)
        return pol_features

# 测试政策特征提取网络
fc_sizes=[128, 64, 32]
model = PolModel(use_poster=False, use_pol_title=True, use_pol_cat=True, 
                 use_age_job=True, fc_sizes=fc_sizes, max_pol_id=max_pol_id, 
                 policy_cat=policy_cat, policy_title=policy_titles)
model.eval()


for idx, data in enumerate(train_loader):
    # 获得数据，并转为动态图格式
    usr, pol, score = data
    # 只使用每个Batch的第一条数据
    pol_v = [var[0:1] for var in pol]
    print("输入的政策ID数据：{}\n类别数据：{} \n名称数据：{} ".format(*pol_v))
    pol_v = [paddle.to_tensor(var) for var in pol_v]
    pol_feat = model.get_pol_feat(pol_v)
    print("计算得到的政策特征维度是：", pol_feat.shape)
    break

我的报错

NameError                                 Traceback (most recent call last)
Cell In[31], line 100
     97 # 测试政策特征提取网络
     98 fc_sizes=[128, 64, 32]
     99 model = PolModel(use_poster=False, use_pol_title=True, use_pol_cat=True, 
--> 100                  use_age_job=True, fc_sizes=fc_sizes, max_pol_id=max_pol_id, 
    101                  policy_cat=policy_cat, policy_title=policy_titles)
    102 model.eval()
    105 for idx, data in enumerate(train_loader):
    106     # 获得数据，并转为动态图格式

NameError: name 'max_pol_id' is not defined

但在代码的第4行，15行，和21行我已经定义过 'max_pol_id'，为什么还会nameerror呢？

PolModel类,内部定义的变量属于类变量. 在第100行,实例化时,=右边的是外部（类以外）的变量,需要自己重新定义.
max_pol_id, policy_cat, policy_titles这三个外部变量都需要重新定义赋值.具体请参照fc_sizes 那样去定义,传参.

就是这个模块没有被定义

变量没定义
传参的时候你要传值啊，不要把形参名字写这里
这一堆变量只有fc_sizes定义了，其他都没定义

第一个max_pol_id被赋值，算是定义；第二个是获取值赋给其他变量，这个变量哪来的？

你没有定义是下面这里没定义，你上面定义的是类的参数，但是你调用的时候对参数赋值的这个max_pol_id你定义在哪里了