python基于机器学习的文本分类系统(python+django+mysql+html+bootstrap)

私信源码获取及调试交流

私信源码获取及调试交流

运行环境

Python>=10、MySQL≥5.7

开发工具

Pycharm(推荐)

适用

课程设计，大作业，毕业设计，项目练习，学习演示等

功能说明

基于javaweb的Python基于机器学习的文本分类系统(python+django+mysql+html+bootstrap)

1 设置虚拟环境

2 安装依赖：

pip install -i https://mirrors.aliyun.com/pypi/simple/ bs4 pymysql Django==3.1 requests gensim jieba

pip install torch==1.12.1+cpu torchvision==0.13.1+cpu -f https://download.pytorch.org/whl/torch_stable.html

3 启动：

python manage.py runserver 8091

4 打开页面：

http://127.0.0.1:8091

账户： 用户名：admin 密码：123456

            phone=phone,
            role=2,
            description=''
        )
        response_data = {'message': '注册成功'}
        return JsonResponse(response_data)
    except Exception as e:
        print(e)
        return JsonResponse({'message': '注册失败'}, status=401)

def password(request):
    username = request.session['username']
    role_id = request.session['role']
    user_id = request.session['user_id']
    return render(request,'modify_password.html',locals())
def get_user(request):
    """
    获取用户列表信息 | 模糊查询
    :param request:
    :return:
    """
    keyword = request.GET.get('name')
    page = request.GET.get("page", '')
    limit = request.GET.get("limit", '')
    role_id = request.GET.get('position','')
    response_data = {}
    response_data['code'] = 0
    response_data['msg'] = ''
    data = []
    if keyword is None:
        results = UserTable.objects.all()
        paginator = Paginator(results, limit)
        results = paginator.page(page)
        if results:
            for user in results:
                record = {
                    "id": user.id,
                    "name": user.name,
                    "password": user.password,
                    "phone": user.phone,
                    "role": user.role,
                    'create_time': user.create_time.strftime('%Y-%m-%d %H:%m:%S'),
                    "desc": user.description,
                }
                data.append(record)
            response_data['count'] =len(UserTable.objects.all())
            response_data['data'] = data
    else:
        users_all = UserTable.objects.filter(name__contains=keyword).all()
        paginator = Paginator(users_all, limit)
        results = paginator.page(page)
        if results:

                    "name": user.name,
                    "password": user.password,
                    "phone": user.phone,
                    "role": user.role,
                    'create_time': user.create_time.strftime('%Y-%m-%d %H:%m:%S'),
                    "desc": user.description,
                }
                data.append(record)
            response_data['count'] =len(UserTable.objects.all())
            response_data['data'] = data
    else:
        users_all = UserTable.objects.filter(name__contains=keyword).all()
        paginator = Paginator(users_all, limit)
        results = paginator.page(page)
        if results:
            for user in results:
                record = {
                    "id": user.id,
                    "name": user.name,
                    "password": user.password,
                    "role": user.role,
                    "phone": user.phone,
                    'create_time':  user.create_time.strftime('%Y-%m-%d %H:%m:%S'),
                    "desc": user.description,
                }
                data.append(record)
            response_data['count'] = len(users_all)
            response_data['data'] = data
    return JsonResponse(response_data)

def user(request):
    """
    跳转用户页面
    """
    username = request.session['username']
    role_id = request.session['role']
    user_id= request.session['user_id']
    return render(request, 'user.html', locals())

def login_check(request):

    role_id = request.session['role']
    user_id= request.session['user_id']
    return render(request, 'user.html', locals())

def login_check(request):
    """
    登录校验
    """
    response_data = {}
    name = request.GET.get('username')
    password = request.GET.get('password')
    user = UserTable.objects.filter(name=name, password=password).first()
    info = {}
    if user:
        # 将用户名存入session中
        request.session["username"] = user.name
        request.session["role"] = user.role
        request.session["user_id"] = user.id
        response_data['message'] = '登录成功'
        return JsonResponse(response_data, status=201)
    else:
        return JsonResponse({'message': '用户名或者密码不正确'}, status=401)

def edit_user(request):
    """
    修改用户
    """
    response_data = {}
    user_id = request.POST.get('id')
    username = request.POST.get('username')
    phone = request.POST.get('phone')
    UserTable.objects.filter(id=user_id).update(
        name=username,
        phone=phone)
    response_data['msg'] = 'success'
    return JsonResponse(response_data, status=201)

def del_user(request):
    """
    删除用户
    """
    user_id = request.POST.get('id')
    result = UserTable.objects.filter(id=user_id).first()

def save_net_epoch(net, epoch):
    net.eval()
    torch.save(net, save_path.get('model'))
    torch.save(epoch, save_path.get('epoch'))

# 模型和输入输出都会保存在这个device中
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

# embedding_weight = get_vector_weight(get_vector_model())
# Config = {
#     # 'embedding_weight': get_vector_weight(model_save), 如果每次将这个config输入进去，之前的优化都失效了，只能让模型随机了
#     'kernel_size': (2, 3, 4),
#     'output_channels': 300,
#     'class_num': 12,
#     'linear_one': 250,
#     'linear_two': 120,
#     'dropout': 0.5,
#     'embedding_weight': embedding_weight
# }

Config = {
    'kernel_size': (3, 4, 5),  # 卷积核的不同尺寸
    'output_channels': 200,  # 每种尺寸的卷积核有多少个
    'class_num': 12,  # 分类数量,见data_loader.categories
    'linear_one': 250,  # 第一个全连接层的输出节点数
    # 'linear_two': 120,
    'dropout': 0.5,  # 随机丢失节点占比
    'vocab_size': 283302,  # 词库大小，即词的数量, len(model.wv.index_to_key))是word2vec模型中的词库大小
    'vector_size': 100  # 每个词的词向量的长度， word = [.....]
    # 'embedding_weight': embedding_weight
}

# in_channels 就是词向量的维度, out_channels则是卷积核(每个kernel_size都一样多)的数量
# 对于一种尺寸的卷积核  kernel_size = 3,in_channels=100,out_channels=50时,
# 设 x = [32][100]即一个新闻数据, 进行卷积操作前，先对x维度进行变换->[100][32]，即每一列是一个词向量，conv1d卷积层左右扫描即可
# x经过卷积操作后会得到[50][30], 分别对应50个卷积核分别对x运算得到的一维数据的结果,即[out_channels][in_channels-kernel_size + 1],
# 然后进行 relu运算，形状不变
# 紧接着进行最大池化操作,每个卷积核运算结果中选出一个最大值,即[30]中选出一个, -> max = [50][1]
# 接着将max转为一维数据 ->[50], 即[out_channels]
# 由于有len(kernel_size)种尺寸的卷积核,所以经过卷积层，池化层有 len(kernel_size) * output_channels 个输出

        return JsonResponse(response_data, status=201)
    except Exception as e:
        response_data = {'message': '删除失败！'}
        return JsonResponse(response_data, status=403)

def change_password(request):
    """
    修改密码
    """

    user = UserTable.objects.filter(name=request.session["username"]).first()
    if user.password == request.POST.get('changePassword'):
        # 修改的密码与原密码重复不予修改
        return JsonResponse({"msg": "修改密码与原密码重复"}), 406
    else:
        # 不重复，予以修改
        UserTable.objects.filter(name=request.session["username"]).update(
            password=request.POST.get('changePassword'))
        # 清除session回到login界面
        del request.session['username']
        return JsonResponse({"msg": "success"})

# coding:utf-8

module_path = os.path.dirname(__file__)

# 模型保存路径
save_path = {
    'model': module_path + '/model_save/model.pth',
    'epoch': module_path + '/model_save/epoch.pth'
}
def get_trained_net():
    net = torch.load(save_path.get('model') ,map_location='cpu')

# in_channels 就是词向量的维度, out_channels则是卷积核(每个kernel_size都一样多)的数量
# 对于一种尺寸的卷积核  kernel_size = 3,in_channels=100,out_channels=50时,
# 设 x = [32][100]即一个新闻数据, 进行卷积操作前，先对x维度进行变换->[100][32]，即每一列是一个词向量，conv1d卷积层左右扫描即可
# x经过卷积操作后会得到[50][30], 分别对应50个卷积核分别对x运算得到的一维数据的结果,即[out_channels][in_channels-kernel_size + 1],
# 然后进行 relu运算，形状不变
# 紧接着进行最大池化操作,每个卷积核运算结果中选出一个最大值,即[30]中选出一个, -> max = [50][1]
# 接着将max转为一维数据 ->[50], 即[out_channels]
# 由于有len(kernel_size)种尺寸的卷积核,所以经过卷积层，池化层有 len(kernel_size) * output_channels 个输出
class NewsModel(nn.Module):
    def __init__(self, config):
        super(NewsModel, self).__init__()
        self.kernel_size = config.get('kernel_size')
        self.output_channels = config.get('output_channels')
        self.class_num = config.get('class_num')
        self.liner_one = config.get('linear_one')
        # self.liner_two = config.get('linear_two')
        self.dropout = config.get('dropout')
        self.vocab_size = config.get('vocab_size')
        self.vector_size = config.get('vector_size')

        # 也可以这么写，不用调用 init_embedding方法，利用已有的word2vec预训练模型中初始化
        # self.embedding = nn.Embedding.from_pretrained(torch.tensor(config.get('embedding_weight')), freeze=False)
        self.embedding = nn.Embedding(num_embeddings=self.vocab_size, embedding_dim=self.vector_size, padding_idx=0)
        # 这里是不同kernel_size的conv1d
        self.convs = [nn.Conv1d(in_channels=self.embedding.embedding_dim, out_channels=self.output_channels,
                                kernel_size=size, stride=1, padding=0).to(device)
                      for size in self.kernel_size]
        self.fc1 = nn.Linear(len(self.kernel_size) * self.output_channels, self.liner_one)
        # self.fc2 = nn.Linear(self.liner_one, self.liner_two)
        self.fc2 = nn.Linear(self.liner_one, self.class_num)
        self.dropout = nn.Dropout(self.dropout)

    # embedding_matrix就是word2vec的get_vector_weight
    def init_embedding(self, embedding_matrix):
        self.embedding.weight = nn.Parameter(torch.tensor(embedding_matrix).to(device))

    # x = torch.tensor([[word1_index, word2_index,..],[],[]])
    # forward这个函数定义了前向传播的运算
    def forward(self, x):

    """
    try:
        name = request.POST.get('username')
        passwd = request.POST.get('password')
        phone = request.POST.get('phone')
        user = UserTable.objects.filter(name=name)
        if user:
            return JsonResponse({'message': '用户已存在,请直接登录'}, status=403)
        UserTable.objects.create(
            name=name,
            password=passwd,
            phone=phone,
            role=2,
            description=''
        )
        response_data = {'message': '注册成功'}
        return JsonResponse(response_data)
    except Exception as e:
        print(e)
        return JsonResponse({'message': '注册失败'}, status=401)

def password(request):
    username = request.session['username']
    role_id = request.session['role']
    user_id = request.session['user_id']
    return render(request,'modify_password.html',locals())
def get_user(request):
    """
    获取用户列表信息 | 模糊查询
    :param request:
    :return:
    """
    keyword = request.GET.get('name')
    page = request.GET.get("page", '')
    limit = request.GET.get("limit", '')
    role_id = request.GET.get('position','')
    response_data = {}
    response_data['code'] = 0
    response_data['msg'] = ''
    data = []
    if keyword is None:

            response_data['data'] = data
    else:
        users_all = UserTable.objects.filter(name__contains=keyword).all()
        paginator = Paginator(users_all, limit)
        results = paginator.page(page)
        if results:
            for user in results:
                record = {
                    "id": user.id,
                    "name": user.name,
                    "password": user.password,
                    "role": user.role,
                    "phone": user.phone,
                    'create_time':  user.create_time.strftime('%Y-%m-%d %H:%m:%S'),
                    "desc": user.description,
                }
                data.append(record)
            response_data['count'] = len(users_all)
            response_data['data'] = data
    return JsonResponse(response_data)

def user(request):
    """
    跳转用户页面
    """
    username = request.session['username']
    role_id = request.session['role']
    user_id= request.session['user_id']
    return render(request, 'user.html', locals())

def login_check(request):
    """
    登录校验
    """
    response_data = {}
    name = request.GET.get('username')
    password = request.GET.get('password')
    user = UserTable.objects.filter(name=name, password=password).first()
    info = {}
    if user:

module_path = os.path.dirname(__file__)

# 模型保存路径
save_path = {
    'model': module_path + '/model_save/model.pth',
    'epoch': module_path + '/model_save/epoch.pth'
}
def get_trained_net():
    net = torch.load(save_path.get('model') ,map_location='cpu')
    net.to(device)
    net.eval()
    return net

def get_epoch():
    return torch.load(save_path.get('epoch'))

def save_net_epoch(net, epoch):
    net.eval()
    torch.save(net, save_path.get('model'))
    torch.save(epoch, save_path.get('epoch'))

# 模型和输入输出都会保存在这个device中
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

# embedding_weight = get_vector_weight(get_vector_model())
# Config = {
#     # 'embedding_weight': get_vector_weight(model_save), 如果每次将这个config输入进去，之前的优化都失效了，只能让模型随机了
#     'kernel_size': (2, 3, 4),
#     'output_channels': 300,
#     'class_num': 12,
#     'linear_one': 250,
#     'linear_two': 120,
#     'dropout': 0.5,
#     'embedding_weight': embedding_weight
# }

def save_net_epoch(net, epoch):
    net.eval()
    torch.save(net, save_path.get('model'))
    torch.save(epoch, save_path.get('epoch'))

# 模型和输入输出都会保存在这个device中
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

# embedding_weight = get_vector_weight(get_vector_model())
# Config = {
#     # 'embedding_weight': get_vector_weight(model_save), 如果每次将这个config输入进去，之前的优化都失效了，只能让模型随机了
#     'kernel_size': (2, 3, 4),
#     'output_channels': 300,
#     'class_num': 12,
#     'linear_one': 250,
#     'linear_two': 120,
#     'dropout': 0.5,
#     'embedding_weight': embedding_weight
# }

Config = {
    'kernel_size': (3, 4, 5),  # 卷积核的不同尺寸
    'output_channels': 200,  # 每种尺寸的卷积核有多少个
    'class_num': 12,  # 分类数量,见data_loader.categories
    'linear_one': 250,  # 第一个全连接层的输出节点数
    # 'linear_two': 120,
    'dropout': 0.5,  # 随机丢失节点占比
    'vocab_size': 283302,  # 词库大小，即词的数量, len(model.wv.index_to_key))是word2vec模型中的词库大小
    'vector_size': 100  # 每个词的词向量的长度， word = [.....]
    # 'embedding_weight': embedding_weight
}

# in_channels 就是词向量的维度, out_channels则是卷积核(每个kernel_size都一样多)的数量
# 对于一种尺寸的卷积核  kernel_size = 3,in_channels=100,out_channels=50时,
# 设 x = [32][100]即一个新闻数据, 进行卷积操作前，先对x维度进行变换->[100][32]，即每一列是一个词向量，conv1d卷积层左右扫描即可
# x经过卷积操作后会得到[50][30], 分别对应50个卷积核分别对x运算得到的一维数据的结果,即[out_channels][in_channels-kernel_size + 1],
# 然后进行 relu运算，形状不变
# 紧接着进行最大池化操作,每个卷积核运算结果中选出一个最大值,即[30]中选出一个, -> max = [50][1]

def login_check(request):
    """
    登录校验
    """
    response_data = {}
    name = request.GET.get('username')
    password = request.GET.get('password')
    user = UserTable.objects.filter(name=name, password=password).first()
    info = {}
    if user:
        # 将用户名存入session中
        request.session["username"] = user.name
        request.session["role"] = user.role
        request.session["user_id"] = user.id
        response_data['message'] = '登录成功'
        return JsonResponse(response_data, status=201)
    else:
        return JsonResponse({'message': '用户名或者密码不正确'}, status=401)

def edit_user(request):
    """
    修改用户
    """
    response_data = {}
    user_id = request.POST.get('id')
    username = request.POST.get('username')
    phone = request.POST.get('phone')
    UserTable.objects.filter(id=user_id).update(
        name=username,
        phone=phone)
    response_data['msg'] = 'success'
    return JsonResponse(response_data, status=201)

def del_user(request):
    """
    删除用户
    """
    user_id = request.POST.get('id')
    result = UserTable.objects.filter(id=user_id).first()
    try:
        if not result:
            response_data = {'error': '删除用户信息失败！', 'message': '找不到id为%s的用户' % user_id}
            return JsonResponse(response_data, status=403)

            return JsonResponse({'message': '用户已存在,请直接登录'}, status=403)
        UserTable.objects.create(
            name=name,
            password=passwd,
            phone=phone,
            role=2,
            description=''
        )
        response_data = {'message': '注册成功'}
        return JsonResponse(response_data)
    except Exception as e:
        print(e)
        return JsonResponse({'message': '注册失败'}, status=401)

def password(request):
    username = request.session['username']
    role_id = request.session['role']
    user_id = request.session['user_id']
    return render(request,'modify_password.html',locals())
def get_user(request):
    """
    获取用户列表信息 | 模糊查询
    :param request:
    :return:
    """
    keyword = request.GET.get('name')
    page = request.GET.get("page", '')
    limit = request.GET.get("limit", '')
    role_id = request.GET.get('position','')
    response_data = {}
    response_data['code'] = 0
    response_data['msg'] = ''
    data = []
    if keyword is None:
        results = UserTable.objects.all()
        paginator = Paginator(results, limit)
        results = paginator.page(page)
        if results:
            for user in results:
                record = {
                    "id": user.id,
                    "name": user.name,
                    "password": user.password,
                    "phone": user.phone,
                    "role": user.role,

def login_check(request):
    """
    登录校验
    """
    response_data = {}
    name = request.GET.get('username')
    password = request.GET.get('password')
    user = UserTable.objects.filter(name=name, password=password).first()
    info = {}
    if user:
        # 将用户名存入session中
        request.session["username"] = user.name
        request.session["role"] = user.role
        request.session["user_id"] = user.id
        response_data['message'] = '登录成功'
        return JsonResponse(response_data, status=201)
    else:
        return JsonResponse({'message': '用户名或者密码不正确'}, status=401)

def edit_user(request):
    """
    修改用户
    """
    response_data = {}
    user_id = request.POST.get('id')
    username = request.POST.get('username')
    phone = request.POST.get('phone')
    UserTable.objects.filter(id=user_id).update(
        name=username,
        phone=phone)
    response_data['msg'] = 'success'
    return JsonResponse(response_data, status=201)

def del_user(request):
    """
    删除用户
    """
    user_id = request.POST.get('id')
    result = UserTable.objects.filter(id=user_id).first()
    try:
        if not result:
            response_data = {'error': '删除用户信息失败！', 'message': '找不到id为%s的用户' % user_id}
            return JsonResponse(response_data, status=403)
        result.delete()
        response_data = {'message': '删除成功！'}
        return JsonResponse(response_data, status=201)
    except Exception as e:
        response_data = {'message': '删除失败！'}
        return JsonResponse(response_data, status=403)

module_path = os.path.dirname(__file__)

# 模型保存路径
save_path = {
    'model': module_path + '/model_save/model.pth',
    'epoch': module_path + '/model_save/epoch.pth'
}
def get_trained_net():
    net = torch.load(save_path.get('model') ,map_location='cpu')
    net.to(device)
    net.eval()
    return net

def get_epoch():
    return torch.load(save_path.get('epoch'))

def save_net_epoch(net, epoch):
    net.eval()
    torch.save(net, save_path.get('model'))
    torch.save(epoch, save_path.get('epoch'))

# 模型和输入输出都会保存在这个device中
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

# embedding_weight = get_vector_weight(get_vector_model())
# Config = {
#     # 'embedding_weight': get_vector_weight(model_save), 如果每次将这个config输入进去，之前的优化都失效了，只能让模型随机了
#     'kernel_size': (2, 3, 4),
#     'output_channels': 300,
#     'class_num': 12,
#     'linear_one': 250,
#     'linear_two': 120,
#     'dropout': 0.5,
#     'embedding_weight': embedding_weight
# }

    net.eval()
    torch.save(net, save_path.get('model'))
    torch.save(epoch, save_path.get('epoch'))

# 模型和输入输出都会保存在这个device中
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

# embedding_weight = get_vector_weight(get_vector_model())
# Config = {
#     # 'embedding_weight': get_vector_weight(model_save), 如果每次将这个config输入进去，之前的优化都失效了，只能让模型随机了
#     'kernel_size': (2, 3, 4),
#     'output_channels': 300,
#     'class_num': 12,
#     'linear_one': 250,
#     'linear_two': 120,
#     'dropout': 0.5,
#     'embedding_weight': embedding_weight
# }

Config = {
    'kernel_size': (3, 4, 5),  # 卷积核的不同尺寸
    'output_channels': 200,  # 每种尺寸的卷积核有多少个
    'class_num': 12,  # 分类数量,见data_loader.categories
    'linear_one': 250,  # 第一个全连接层的输出节点数
    # 'linear_two': 120,
    'dropout': 0.5,  # 随机丢失节点占比
    'vocab_size': 283302,  # 词库大小，即词的数量, len(model.wv.index_to_key))是word2vec模型中的词库大小
    'vector_size': 100  # 每个词的词向量的长度， word = [.....]
    # 'embedding_weight': embedding_weight
}

# in_channels 就是词向量的维度, out_channels则是卷积核(每个kernel_size都一样多)的数量
# 对于一种尺寸的卷积核  kernel_size = 3,in_channels=100,out_channels=50时,
# 设 x = [32][100]即一个新闻数据, 进行卷积操作前，先对x维度进行变换->[100][32]，即每一列是一个词向量，conv1d卷积层左右扫描即可
# x经过卷积操作后会得到[50][30], 分别对应50个卷积核分别对x运算得到的一维数据的结果,即[out_channels][in_channels-kernel_size + 1],
# 然后进行 relu运算，形状不变

    response_data['code'] = 0
    response_data['msg'] = ''
    data = []
    if keyword is None:
        results = UserTable.objects.all()
        paginator = Paginator(results, limit)
        results = paginator.page(page)
        if results:
            for user in results:
                record = {
                    "id": user.id,
                    "name": user.name,
                    "password": user.password,
                    "phone": user.phone,
                    "role": user.role,
                    'create_time': user.create_time.strftime('%Y-%m-%d %H:%m:%S'),
                    "desc": user.description,
                }
                data.append(record)
            response_data['count'] =len(UserTable.objects.all())
            response_data['data'] = data
    else:
        users_all = UserTable.objects.filter(name__contains=keyword).all()
        paginator = Paginator(users_all, limit)
        results = paginator.page(page)
        if results:
            for user in results:
                record = {
                    "id": user.id,
                    "name": user.name,
                    "password": user.password,
                    "role": user.role,
                    "phone": user.phone,
                    'create_time':  user.create_time.strftime('%Y-%m-%d %H:%m:%S'),
                    "desc": user.description,
                }
                data.append(record)
            response_data['count'] = len(users_all)
            response_data['data'] = data
    return JsonResponse(response_data)

def user(request):
    """

    'output_channels': 200,  # 每种尺寸的卷积核有多少个
    'class_num': 12,  # 分类数量,见data_loader.categories
    'linear_one': 250,  # 第一个全连接层的输出节点数
    # 'linear_two': 120,
    'dropout': 0.5,  # 随机丢失节点占比
    'vocab_size': 283302,  # 词库大小，即词的数量, len(model.wv.index_to_key))是word2vec模型中的词库大小
    'vector_size': 100  # 每个词的词向量的长度， word = [.....]
    # 'embedding_weight': embedding_weight
}

# in_channels 就是词向量的维度, out_channels则是卷积核(每个kernel_size都一样多)的数量
# 对于一种尺寸的卷积核  kernel_size = 3,in_channels=100,out_channels=50时,
# 设 x = [32][100]即一个新闻数据, 进行卷积操作前，先对x维度进行变换->[100][32]，即每一列是一个词向量，conv1d卷积层左右扫描即可
# x经过卷积操作后会得到[50][30], 分别对应50个卷积核分别对x运算得到的一维数据的结果,即[out_channels][in_channels-kernel_size + 1],
# 然后进行 relu运算，形状不变
# 紧接着进行最大池化操作,每个卷积核运算结果中选出一个最大值,即[30]中选出一个, -> max = [50][1]
# 接着将max转为一维数据 ->[50], 即[out_channels]
# 由于有len(kernel_size)种尺寸的卷积核,所以经过卷积层，池化层有 len(kernel_size) * output_channels 个输出
class NewsModel(nn.Module):
    def __init__(self, config):
        super(NewsModel, self).__init__()
        self.kernel_size = config.get('kernel_size')
        self.output_channels = config.get('output_channels')
        self.class_num = config.get('class_num')
        self.liner_one = config.get('linear_one')
        # self.liner_two = config.get('linear_two')
        self.dropout = config.get('dropout')
        self.vocab_size = config.get('vocab_size')
        self.vector_size = config.get('vector_size')

        # 也可以这么写，不用调用 init_embedding方法，利用已有的word2vec预训练模型中初始化
        # self.embedding = nn.Embedding.from_pretrained(torch.tensor(config.get('embedding_weight')), freeze=False)
        self.embedding = nn.Embedding(num_embeddings=self.vocab_size, embedding_dim=self.vector_size, padding_idx=0)
        # 这里是不同kernel_size的conv1d
        self.convs = [nn.Conv1d(in_channels=self.embedding.embedding_dim, out_channels=self.output_channels,
                                kernel_size=size, stride=1, padding=0).to(device)
                      for size in self.kernel_size]
        self.fc1 = nn.Linear(len(self.kernel_size) * self.output_channels, self.liner_one)
        # self.fc2 = nn.Linear(self.liner_one, self.liner_two)
        self.fc2 = nn.Linear(self.liner_one, self.class_num)

def edit_user(request):
    """
    修改用户
    """
    response_data = {}
    user_id = request.POST.get('id')
    username = request.POST.get('username')
    phone = request.POST.get('phone')
    UserTable.objects.filter(id=user_id).update(
        name=username,
        phone=phone)
    response_data['msg'] = 'success'
    return JsonResponse(response_data, status=201)

def del_user(request):
    """
    删除用户
    """
    user_id = request.POST.get('id')
    result = UserTable.objects.filter(id=user_id).first()
    try:
        if not result:
            response_data = {'error': '删除用户信息失败！', 'message': '找不到id为%s的用户' % user_id}
            return JsonResponse(response_data, status=403)
        result.delete()
        response_data = {'message': '删除成功！'}
        return JsonResponse(response_data, status=201)
    except Exception as e:
        response_data = {'message': '删除失败！'}
        return JsonResponse(response_data, status=403)

def change_password(request):
    """
    修改密码
    """

    user = UserTable.objects.filter(name=request.session["username"]).first()
    if user.password == request.POST.get('changePassword'):
        # 修改的密码与原密码重复不予修改
        return JsonResponse({"msg": "修改密码与原密码重复"}), 406
    else:
        # 不重复，予以修改
        UserTable.objects.filter(name=request.session["username"]).update(
            password=request.POST.get('changePassword'))
        # 清除session回到login界面
        del request.session['username']