Skip to content

P
PaddleHub

PaddlePaddle / PaddleHub
接近 2 年 前同步成功

通知 284
Star 12117
Fork 2091
P
PaddleHub
提交 a00bc6a9 编写于 作者: Z Zeyu Chen
浏览文件
操作

update module load api

上级 277aae4a
隐藏空白更改
内联 并排
Showing with 62 addition and 44342 deletion
Senta/create_module.sh 已删除 100755 → 0
浏览文件 @ 277aae4a
python test_create_module.py --train_data_path ./data/train_data/corpus.train --word_dict_path ./data/train.vocab --mode train --model_path ./models
Senta/data/test_data/corpus.test 已删除 100755 → 0
浏览文件 @ 277aae4a
2 我 想 当初 让 我 决定 购买 锋范 的 最大 理由 还是 对 品牌 的 追求 吧 本田 在 国人 的 印象 中 相对 其他 日系 品牌 要 更好 一点
0 买 来 开 了 研究 后 才 发现 原来 本田锋范 是 小型车 研究 了 各项 尺寸 轴距 跟 A级车 有 那么 一点 差距 晕倒 小型车 卖 紧凑型车 的 价格 哎 谁 叫 他 是 本田 呢
0 貌似 操控 差 了 点 185 的 轮胎 加上 后轮 扭力 梁 整车 刚性 又 不 怎么 好 直线 开开 还是 不错 的 要是 告诉 过 弯 还是 算了吧 老老实实 开 吧
2 外观 绝对 是 同 级别 最 好看 之 一 了 不管 从 哪一个 角度 看 都是 很 流畅 的 线条 唯一 不足 的 是 车子 太 小 了 一点 要是 再 大 一点 那 就 完美 了 其实 跟 思域 还是 有 一点 像 的
2 内饰 蛮 年轻 的 而且 看上去 质感 都 蛮好 貌似 本田 所有 车 都 有点 相似 满 高档 的
2 比 奔驰 宝马 比 不 了 比 相应 的 的 车辆 小五 你 是 第一
0 美国 车 就是 费 油 既然 你 买 的 起 就能 烧 得 起 油
0 一个 规格 差 三千 总体 来说 我 的 车 还是 买 的 比较 便宜 的 但是 什么 都 没有 送 最 起码 你 座套 得 送 吧 人 就 俩字 没有 脚垫 呢 没有
0 就是 五菱 太 扣 了 。 送 个 扶手箱 才 一百元 的 事 。 一套 坐垫 也是 一百元 的 事 一套 脚垫 也是 一百元 的 事 。 总共 三百元 的 事 总 比 一个 差评 好 吧 。 不过 总体 还 可以 了 买车 时 你 多 砍价 省出来 么 就 都 有 了 对 吧
2 动力 不做 ， 1.8T 已经 满足 我 的 需求 ！
2 搭配 7速 双 离合 ， 还是 比较 省油 的 ！
0 悬挂 还是 马马虎虎 ， 比上不足 ， 比下有余 ！
2 内饰 不错 ， 运动 包皮 很 耐看 动感
2 总体来说 我 对 这个 价位 ， 这个 空间 的 景逸 很满意 ， 很 适合 我 ， 其实 买车 跟 娶 老婆 一样 ， 最最 要 的 是 要 选择 合适 自己 的 。
2 驾驶 坐姿 高 ， 视野 开阔 ； 油门 踏板 轻盈 ； 底盘 通过 性 强 。 A 柱 挡 眼 ， 因 轴距 短 转弯 时 车体 有 轻微 抖动 。
2 外观 时尚 ， 线条 流畅 ， 前脸 霸气 ， 后 屁股 性感 ， 车身 整体 表现出 年轻 的 活力 和 风度 。
0 黄色 真 的 不是 很好
2 整体 效果 还不错 ， 说 真 的 10万 以下 的 SUV 我 感觉 买 瑞虎 买 对 了 。 瑞虎 ！ 你 值得 拥有 ， 呵呵
2 做工 很好 ， 材质 也 很不错 ！
2 买 它 不 后悔 ， 已经 替 我 挣 了 不少 钱 了
2 说不上 哪 点 最 满意 ， 综合 起来 还是 很好 的
2 空间 是 可以 了 ， 后面 坐 三个 170斤 的 人 也 不 嫌 挤 ， 但 矮 了 点 ， 后备箱 给力
1 满分 是 10分 的 话 ， 性价比 给 8.5分 吧 ！ 综合 油耗 偏高 ， 如果 开市区 的 就 不太 合算 了 。
0 后排 中间 的 突起 太 高 ， 中间 坐 人 不好 放 脚 。
1 一般 ， 家用 还 可以 。
2 过去 开 面包车 ， 现在 开 和悦rs 13款 那 感觉 当然 的 不一样 。 非常 的 舒适 满意 ， 为 买 13款 我 等 了 1 年多 ， 等到 13款 上市 才 买 此 车 ， 够 痴情 吧 。
0 舒适性 不知道 怎么 说 , 椅子 舒适性 一般般 , 坐 在 前排 还 可以 ， 后排 过 减速带 , 小 坑 等等 就 明显 感到 振动 很大 。
2 相当 满意 ！ 炫耀 的 资本 ！ ！
2 车辆 非常 轻盈 有力 ！ 开 起来 非常 舒服 ！
2 与 同 价位 ， 同 级别 的 车 相比 ！ 性价比 最高 ！
1 刚 提 车 的 时候 30 + 的 油耗 ， 现在 已经 被 我 努力 开到 9 了 ， 最少 的 时候 开出 过 3.9L / 100KM ， 很 有 成就感 啊 ， 给 自己 的 预算 就是 5 - 6 毛钱 一公里 的 油 费
0 后备箱 太 小 了 ， 放下 一个 婴儿车 就 基本 放不下 其他 东西 了
0 用料 不行
2 耐看型 ， 最 开始 觉得 一般 ， 用 了 几个月 ， 越发 觉得 好看 ， 流线 车身 很 符合 我 一个 年轻人 的 审美 。
2 总的来说 ， 这 是 一款 买 了 不会 后悔 的 车 ， 当初 在 排除 日韩 车 后 ， 基本 看 扁 了 10 - 20W 的 车 ， 福克斯 太 窄 ， 速腾 太坑 ， 英朗 太笨 。 其他 什么 508 C5 迈瑞宝 中级 车 既 不符合 年轻人 也 没 小 四 耐看 ， 而且 低 配 动力 更 不足 。 在 对比 之 下 ， 真 的 找 不 出 小四 的 缺点 了 ， 所以 在 预算 15W 左右 的 C4L 绝对 是 一款 不错 的 选择 。 希望 对待 够 的 您 有 帮助 。
1 较 低 ， 新手 油耗 暂时 还 比较 高 ， 还有 下降 空间 。
1 内饰 颜色 太 深 ， 浅色 最好 了
1 在 国产车 里 ， 觉得 性价比 和 质量 还算 可以 ， 毕竟 只是 几万元 的 车子 ， 注定 了 要 包容 一些 不足 的 ， 买车 到 现在 2年 了 ， 跑 了 5万多公里 ， 经过 我 一些 小 改动 ， 开 得 还算 得心应手 。
2 还是 铃木 的 发动机 . . 皮实 耐用
1 一般般 . . . 还是 有 点 肉 . . . 不过 跑 起来 也 不错 . . .
2 空间 不错 ， 这么 小 的 车 能 有 这样 的 表现 已经 超出 我 想象 。 特别 是 头部 空间 充足
2 对于 微型车 来说 ， 舒适性 比 两轮 的 摩托车 要好 很多 ， 我 就是 觉得 刮风 下雨 的 时候 还 开 小 Q 舒服
1 目前 9.2L / 100KM ， 计算 大概 在 9.6 ， 南京 的 路 就是 堵 ， 而我 一般 就 短途 ， 也 不 经常 开 ， 基本 就 周末 开开 出去 玩玩 购 购物 走走 的 亲戚 ， 而且 我 每次 开车 都 热车 到 1000转 ， 这样 的 油耗 差不多 了
1 高速 油耗 还不错 ， 5.5-6L ， 但 在 市内 平均 车速 50KM 的 情况 下 油耗 达到 10L / 百公里 ， 还是 偏高 些 ， 特别 需要 指出 的 是 电脑 综合 油耗 误差 较大 ， 平均 油耗 10L 但 电脑 显示 基本 是 8L 。
0 动力 稍 显 疲软 ， 高速 风 噪 较大 ， 悬挂 较 硬 ， 舒适性 欠佳 ， 高 车身 激烈 驾驶 侧倾 明显 。
1 乘坐 空间 大 ， 视野 好 ， 人 坐 在里面 不 局促 ， 但 悬挂 较 硬 ， 震动感 较 明显
1 内饰 一般 ， 定位 于 几万 的 小车 ， 硬 塑料 的 材质 是 可以 接受 的
1 老生长 谈 的 油耗
2 比较 满意
2 内饰 是 不错
2 我 的 小F 入 弯 啊 ， 刹车 啊 ， 都 很自如 。 我 很喜欢 。
2 该 款 车 用 起来 皮实
2 自驾东 游 了 1万多公里 ， 各种 路面 跑起来 没有 发现 不适
1 基本上 油耗 在 工资 能够 忍耐 的 限度 内
2 空间 很大 ， 尤其 是 驾驶员 位置 调整 好 后 ， 坐 到 后排 ， 按 1.7m 的 标准 ， 基本上 有 2拳 以上 的 空间 ， 一家 出去玩 非常 舒服 ， 空间 绝对 是 引 以为 傲 的 地方 。 并且 后备箱 的 深度 也 很大 ， 基本上 能 满足 日常 要求 。 出去玩 的 话 真 的 很 能 装 东西 。
2 2.0t 的 动力 非常好 ， 可以说 是 随叫随到 ， 心 随意 动 。 想 什么 时候 有 就 什么 时候 有 ， 尤其 有 感觉 ， 一点 都 不 费力 。 就算 坐 满人 上坡 也是 很 有信心 的 ， 加上 配合 6速 双离合变速箱 绝对 是 黄金 搭档 。 在 这个 级别 的 车 能 用到 2.0t 的 发动机 绝对 是 独一无二 的 。
0 噪音 太 大
0 不 是 太 细致
2 车身 轻量化 是 日本 车 的 优势 所在 不 加 涡轮 增压 的 发动机 燃油 经济性 还行
0 一般 ， 用料 较差 ， 总 控 太 塑料感 太 强 ， 做工 不错 。
2 很 有 质感 ， 我喜欢 。
0 有点 窄 。 就是 副 驾驶 没 自动
2 比较 温馨 。 。 软 内饰
2 多媒体 加 真皮 座椅 ， 确实 还 不赖 。
2 后排座 还 可以 ， 后备箱 在 大 点 就好 了
1 大气 给 人 一种 霸气感 ， 屁股 有点 太 翘 了 点 。 倒 车灯 太 暗 。
2 空间 大 ， 外观 大气 !
0 价格高 ， 4S店 一分 都 不用 优惠 ， 配置 不是 很满意 。
0 A柱 转弯 时 很 挡 视线 ， 很多次 左 转弯 盲区 很大 啊 ， 脖子 要 扭 着 点 ， 看清楚 点 才 放心 开车 啊 ， 这 是 开车 过程 中 发现 的 最 不好 的 一点 ！
2 后排 空间 很大 ， 后备箱 也 不 小 ， 家用 足够 了 ， 后排 座椅 放倒 ， 可以 放 得 下 侧 踏板 , 够 长 了 ！
0 减震 略 差 ， 噪音 还 可以 再 改善 ， 其余 都 还 满意 ！
1 高 ， 果断 入手 之 ， 唉 ， 当初 该 忍 忍 ， 现在 入手 13款 的 ， 更 好看 ！
1 英朗 总体来说 还是 比较 满意 的 ， 不过 变速箱 漏油 的 现象 非常 普遍 ， 车 内 异响 也 比较 多
2 前 麦逊 后 多 连杆 独立 悬挂 形式 ， 底盘 调教 以 舒适性 为主 ， 油门 很 轻 ， 整车 较 重 ， 地盘 平稳 ， 车身 稳定性 较好 ； 方向盘 手感 不错 ， 电子 助力 很 爽 啊 ； 整体 操控 灵动 ； 变速 系统 平稳 而 灵敏 ； 高速 转弯 有点 侧倾 。
0 悬挂 有点 硬 ， 过 砍 都是 崩 崩 的 ， 音响效果 一般 ， 音乐 发烧友 建议 改改 ， 我 就 有 这 计划 。
2 由于 我 的 车 是 P版 ， 基本 该 有 的 都 有 ， 也 不用 改 啥 ， 总体 不错 ， 是 一款 性价比 不错 的 车 。 下面 把 我 的 车 D 版 没有 的 列下 ： 方向盘 换挡 、 定速 巡航 、 疝气 大灯 、 自动 大灯 、 电动 座椅 记忆 、 后排 座椅 加热 、 后排 中央 扶手 的 功能 按键 、 后视镜 记忆 、 后座 出 风口 、 LED 尾灯 、 后视镜 倒车 影像 、 车头 中网 、 前排 头部 气帘 ， 侧 气帘 、 胎压 监测 装置 、 大灯 清洗 装置 。 爽 吧 ， 多 了 这么多 配置 ， 建议 大家 还是 买 P 版 ， 性价比 高 。
2 油耗 很好 对于 同级 车 的 很 不在
0 纵向 空间 太 小
0 1.6 的 动力 小
2 车辆 外形 好 ， 大气 ，
2 手动挡 ， 操控 比较好 ， 转向 指向性 准确 。
1 整体 比较 舒适 ， 驾驶 起来 也是 挺 舒服 的 ， 空调 有点 不 稳定 ， 刚刚 买车 的 时候 ， 空调 很 冷 的 ， 但是 开 久 了 ， 空调 越来越 觉得 差 了 。
2 1.6DVVT + 5档 手动 ， 发动机 属于 高转速 发动机 ， 要 舍得 给 油 ， 加速 也 不错 。 手动 变速箱 手感 也 挺好 的 ， 开 了 一年 了 ， 挂档 越来越好 挂 。
2 属于 耐看型 ， 越 看 越 顺眼 。
0 感觉 车身 单薄 ， 高速 时 发 飘 。
0 车头 太 小
2 在 2。0L 自然 吸气 的 发动机 算是 较好 的 ， 加速 性能 和 马 6 2。0 相仿 ， 但是 隔音 和 底盘 更好 ， 加速 感觉 更为 线性 ， 常 不知不觉 就 上 到 120km 了 。
2 高速 性能 非常好 ， 上 到 150 － 160 不 觉得 飘 。
1 够用 的 , 家里 没有 那种 个子 特别 高 的 . 储物 空间 是 个 败笔
0 一般 吧 .
0 目前 为至 , 上 过 两次 高速 , 平时 也 就 出去玩 开开 . 车子 没 遇到 过 什么 大 问题 , 就是 车身 的 漆 太 薄 呢 , 不 注意 的 时候 上面 就 有点 啥 痕迹 呢 , 很 是 郁闷 , 还有 啊 , 最近 苏州 有 一次 小 冰雹 , 车顶 和 引擎 盖上 有 不少 小 坑 , 比较 明显 的 那种 , 但是 旁边 的 车 一个 都 没有 . 我们 附近 的 几辆 车 都 没有 发现 被 冰雹 杂 出 坑 的 现象 . 咨询 售后 说 不在 保修 范围 内 . 唉 , 就 这 车身 也 太 脆弱 呢 . 都 有点 想 把 这 车 卖 呢 , 感觉 开 这 车 上路 心里 很 没 安全感 啊 .
2 空间 巨大
0 动力 一般 ， 120码 要 3000 转
2 舒适性 还 可以 ， 起码 空间 大
0 内饰 老气 ， 做工 不错 ， 异响 也有
2 不错 好 操作
2 很 运动 符合 年轻人 的 感官
2 操控 还 可以 ， 比较 舒适 ， 但是 减震 偏 硬 ， 如果 再 改进 下 减震K5 可以 更出色 ， 轮胎 胎噪 过大 ， 高速 行驶 100迈 的 速度 音响 音量 13 胎噪 还是 可以 清晰 听到 ， 希望 2013款 可以 更换 下 轮胎
2 ： 黑 内 配 白 外 的 搭赠 永远是 经典 款 ， 坐 进 车 里 ， 真皮 座椅 和 真皮 包裹 的 中控台 ， 一下子 抛弃 了 那种 塑料感 ， 给 人 一种 豪车 的 感觉 ， 在 感受到 全景 天窗 等 丰富 的 配置 ， k5 一下 就 给 我 留下 了 很 深刻 的 印象
0 油耗 有点 大 ， 靠近 7个 油
0 动力 一般 ， 一档 ， 二档 ， 有 点 肉 ， 三档 是 我的最爱 。
1 座椅 包裹性 很 强 ， 静音 不行
2 6.7万元 的 车 在里面 是 配置 最高 的
2 车 空间 大 ， 前脸 好看 ， 而且 价格 优惠 ！
2 空间 挺 大 的 ， 比 着 同类 价位 的 车 都 好 ！
2 车 不错 ， 我 又 不是 飙车 的 ！ 刚刚 的 ！
2 还不错 ， 档位 清晰 ， 就是 有时候 倒档 不好 挂 ！
2 车型 的 外观 ， 很 动感 、 很 运动 ！
1 ： 一般 ， 稍微 有点 高 ， 特别是 怠速 的 时候 。 但是 长途 高速 很 节油
2 挂挡 入位 ， 倒车 ， 行车 ， 等 操控 都 还不错
2 简洁 。 。
0 1.0 的 排量 有点 小 。 开 空调 动力 损失 大
2 因为 有 助力 ， 开 起来 很 轻 ， 底盘 低 ， 车 体宽 （ 同 级别 ) 高速 140 都 不 觉得 飘 ， 面包 90 就 感到 飘 了 。 刹车 也 很 给力 ， 曾经 高速 120一脚 杀 到 40 . 都 没 甩尾 ， 因 低 的 底盘 开 起来 才 有 轿车 的 感觉 。 车 短 ， 停车 都 很方便
2 外观 是 我 最 满意 的 ， 买车 之 前 就 关注 熊猫 很久 ， 有 段 时间 都 不 打算 买车 了 ， 突然 就 买 了 。
2 外形 时尚 动感
2 外观 大气
1 9 到 10个 平均 时速 19
2 车子 不错 ！
2 已 够用 ， 很 猛 ， 要 舍得 踩 油门 。
0 表面 油漆 太软 , 轻轻 撞 一点 就 见底 , 前 大包围装配接缝 较大 , 特别 是 与 大灯 接缝 太 大 , 能 看见 里面 的 小 螺丝 孔 , 大灯 亮度 不够 , 对 晚上 行车 增加 了 安全 风险 , 备胎 小 几几 的 样子 我 真 的 不能 接受 ,
2 我 跑 高速 油耗 在 7.0 - - 7.8 之间 ( 全程 空调 ) 市区 10.0 - 11.5 , 油耗 还 可以 接受
2 大气 , 时尚 大方 , 锋利 的 腰线 , 性感 PP ,
2 性价比 超群 . 动力 强劲 。 车 的 稳定性 强
1 买 这 小车 吧 也 就 去 个 超市 上 个 班 走走 ， 没想过 跑 长途 ， 都是 眨眼 就 到 的 ， 所以 根本 就 没有 什么 不舒服 的
0 内饰 一般 啦 ， 有些 质量 不是 很好
0 动力 很 OK ， 配件 很 垃圾 ， 贵 啊
0 后备箱 ， 大 的 物件 啥 也 不能 放 ， 上次 去 岳父 家装 了 点 菜 就 满 了 。
2 在 舒适性 上 这么说 呢 ， 就 这个 价位 而言 的 话 这款车 的 舒适性 还是 比较 过关 的 。 可能 是因为 跨界 车 的 缘故 吧 ， 噪音 还是 有点 的 。 红黑 相间 的 皮质 座椅 坐 上去 感觉 还不错 ， 在 等人 的 时候 打开 音乐 点支 小 烟 ， 比较 惬意 。
2 开 了 快 一个月 了 ， 总体 感觉 还不错 ， 现在 我 的 小白 4 是 63900 买 的 给 媳妇 开 的 ， 因为 媳妇 的 驾照 还 没 考 出来 ， 我 代为 磨合 。 这一个月 开 着 的 感受 就是 ， 反正 又 不 真 去 野外 山区 开 ， 这个 价位 买 的 SUV 开 着 比 肖克 、 途观 还有 感觉 。
2 空间 超大 ， 操控性 好 ， 动力 够用 ， 视野 宽阔 ， 安全性 较好 。
1 本人 身材 偏 小 ， 所有 后排 空间 还 凑合
1 经常 跑 高速 ， 所以 至今 综合 8.8
2 诸多 人性化 配置 ， 随动 转向 ， 自动 大灯 ， 自动 雨刮
2 个人 感觉 很好 方向盘 很好 打
0 黑色 的 很容易 脏 还有 就是 后 箱 没有 升降器
2 当初 刚 买 来 的 时候 不太 会 开车 油门 放 太 快 让 人 有 种 很 强 的 顿挫感 现在 好 了 这个 问题 也 什么 事 ！ 油门 的 踩 放 别太急 循 序 接近 就 好多 了 ！ 还有 就是 30码 的 时候 提速 需要 一点 时间 不会 你 给 油 就 提 上来 的 本人 是 新手 也 说不出 什么 好 的 意见 只能 把 自己 感觉到 的 说 了 总而言之 这 车 没有 让 我 失望 也 没有 后悔 购买
0 上坡 要命 啊 ， 吓死 我 了 ， 有 一次2档 地板 油 上 超市 地上 车库 , 上 着 上 着 车子 越来越 没 动力 了 ， 我 中间 也 没 踩刹车 ， 可是 不管 怎么 踩 油门 车子 没有 反应 ， 换 1档 踩 油门 继续 ， 这下 车轮 原地 空转 ， 然后 让 我 体验 了 一把 赛车 的 感觉 啊 ， 一身 白毛 汗 啊 , 我 小舅子 的 凯越 3档 就 可以 冲 上去 ， 换 我 的 车 开 过 之后 他 就 说 我 这 车 动力 不行 , 在 起步 加速 的 时候 很 弱 ， 低档 加速 好 慢 , 3档 以上 加速 还行 ， 不愧为 高速 发动机 啊 ! 给 我 的 感觉 就是 车速 越 快 这 车 就 越好 开 ， 车速 越 慢 就 越 悲催 ， 1.6 车 还 跟 人家 彪 车 啊 ， 就 我们 中国 的 大马路 也 就 高速公路 上 还能 体验 一把 了 , 如果 你 喜欢 开 快车 那 这 车 比较 对 你 的 胃口 ， 至于 我 嘛 ， 我 不 喜欢 开 快车 ， 所以 我 买 错车 了 ， 当初 也是 被 5 连杆 吸引 的 , 没办法 大众神车 就是 神 啊 ， 即使 是 减配 了 可 还是 神 啊 , 至少 他 起步 加速 就是 快 , （ 我 开 过 同学 的 朗逸 ）
2 还好 吧 ， 对 得 起 2.0T 的 排量
2 1.5 排量 的 这种 动力 可以 了 。 虽然 提速 慢 ， 但 高速 上 跑 155 ， 相当 稳 。 和 家里 另 一台 1.5 排量 的 比 强 得 多
2 内饰 满意 ， 有 好多 人性化 的 储物 格 。 真皮 座椅 没有 异味 。 选 车 时 ， 我 看 过 悦动 ， 被 车 内味 一下 熏 跑 了 。
0 塑料件 的 塑料感 太 强 ， 看起来 好 低档 。
2 个人 觉得 明锐 是 斯柯达 系列 里 最 漂亮 的 了 。 前脸 大气 ， 尾部 庄重 。 有点 老年 车 的 意思 ， 不过 选择 白明 ， 在 装饰 点贴花 ， 立马 年轻 10岁 。
2 非常 满意
2 空间 确实 很大 ， 前排 后排 都 很 宽敞 ！ 1 后备箱 稍微 小点 。 本人 身高 1.81 驾驶 位置 ， 和 后排 都 很 宽敞 ， 不 窝腿
2 我 的 是 中 配 的 ， 内饰 感觉 还 可以 ； 我 个人 对 内饰 平常 很少 在意 。
2 骐达 作为 人生中 第一部 车 真 的 很不错 ； 我 好 几个 同事 ( 网络工程师 ) 第一辆 车 都是 骐达 。 照片 是 爱车 的 PP ； 贴上 此 车标 ， 感觉 确实 很少 人 按 喇叭 滴 我 了 ！ 哈哈
2 油耗 基本 满意 ， 市区 百公里 9升 多 ， 跑 高速 8升 左右 。 本人 跑 了 13000多公里 平均 油耗 9.2升 ， 这 也 和 自己 的 驾驶 习惯 有 很大 的 关系 ， 总体来说 油耗 还在 接受 范围 内 。
2 对于 主打 家用 车型 来说 ， 卡罗拉 无疑 是 做 的 最 成功 的 ， 毕竟 4000万 的 销量 在 那 放 着 。 但 现在 同 级别 车型 日益 更新 的 今天 ， 丰田 你 不 觉得 有 压力 吗 。
2 超级喜欢 小指 的 外观 ！
0 动力 稍 弱 啊 ~ ~
2 从 买车 到 现在 一个月 ， 跑 了 3000公里 了 ， 开始 选 车 的 时候 和 老婆 起 了 争议 ， 僵持 了 一个多星期 ， 老婆 说 买途观 ， 但是 我 觉得 途观 没 个性 ， 并且 感觉 有点像 中年人 开 的 ， 老婆 就 觉得 小指 的 配置 没有 途观 高 ， 个人 觉得 有些 配置 是 没 必要 的 ， 有时候 一年 都 不 碰 一次 ， 其实 还是 要 自己 喜欢 吧 ， 但是 最好 老婆 还是 妥协 了 ， 哈哈 ， 接 车 的 那天 老 高兴 了 ， 但是 SSSS 店 有点 小气 ， 什么 礼品 都 没 送 ， 哎 ~ ~ ~ 目前 跑 了 3000公里 ， 油耗 市区 11 - 12个 ， 长途 8.5 ， 还在 接受 范围 之 内 ， 并且 觉得 空间 也 够用 了 ， 也 能 装 下 不少 东西 ， 动力 方面 反正 我 觉得 是 够用 了 ， 因为 小指 毕竟 是 越野车 ， 想要 强大 的 动力 或者 速度 与 激情 的 话 当然 买 轿车 哈 ~ ~ 当然 也 可以 买 大 切 一类 的 ， 俺 是 非常 喜欢 大切 的 ， 就是 经济 条件 不 允许 ， 所以 先 娶 个 小切 吧 ~ 哈哈 。 目前 小切 经过 大风 大雨 ， 没 发现 天窗 漏水 等 问题 ， 感觉 很 欣慰 ， 不 多 说 了 ， 看图 吧 ~ ~ ~ 注意 ： 个人 观点 ， 不喜 勿 喷 ！ ~ ~ 谢谢 ！
0 动力 不足 ， 起步 稍微 有点 慢
2 其实 有很多 。 一发 动机 世界 10佳 ， 动力 足够 ， 而且 使用 93号 汽油 ； 二 安全性 超高 ， 据说 车 内 人员 死亡率 为 00 ； 三 车型 够 酷 ， 外形 很 吸引 人
1 2.0T 无 四驱 。 之 前 一直 想 买 4 四驱 SUV , 但是 看到 此 车 2.0T ， 被 其 优点 吸引 ， 放弃 四驱 ； 刚 400公里 的 时候 低速 熄火 ， 挺 难堪 恐怖 的 一件 事情 。 现在 900公里 没有 在 发生 过 ， 不知道 后面 会 怎么样
2 感觉 不错 ， 没 开 过 其他 车 ， 第一辆 车 ， 感觉 告诉 很 爽 ， 140 稳 得 很 。
2 建议 直接 上高配 ， 买 回来 之后 自己 加装 了 不少 东西 ， 折腾 下来 比 高配 的 都 贵 ， 哈哈 ， 得不偿失 啊 ， 总体来说 还是 个 好车 ， 以后 换 车 应该 会 继续 考虑 雪铁龙 。
2 作为 职业 司机 来讲 我的选择 是 对 的
2 新 速腾 的 性价比 可以说 是 A级 中 最低 的 ， 几乎 是 全国 无 优惠 ， 更 甚至 黑心 的 4S 再 加价 加 配 后 的 价钱 已经 是 B级车 的 价钱 了 ， 但是 喜欢 就是 喜欢 ， 我 想 和 我 一样 买 新 速腾 的 除了 喜欢 外观 之外 ， 更重要 的 是 速腾 体现 了 家用车 的 综合 经济性 。
2 主 副 驾驶 空间 都 还算 宽敞 ， 视野 很好 ， 避震 软硬 适中 ， 适合 多种 路况 。
0 售后 太 差 ！
2 综合 的 油耗 低 、 全 车 配置 和 功能 适用性 高 而 无需 增加 配置 、 操控 比较 精准 、 音响效果 还 可以 。
2 很 耐看 ， 越 看 越 顺眼 ， 肌肉感 很 强 。 后 屁股 太 有 个性 了 ， 呵呵 。
2 个人 认为 本 车 的 超大 空间 在 普通 家用 轿车 的 队伍 里 是 无人 可以 匹敌 的 ， 只能 跨界 同 SUV 比较 。
2 外观 经过 几次 小型 改装 后 ， 本人 很 是 喜欢 。 尾部 秃秃 的 感觉 没有了 ！ 整体 日系 风范 毕露 。
2 易 上手 。
2 新手 感觉 还行
2 新手 总体来说 不错 的
1 1.6L 的 发动机 ， 很多人 都 说 肉 ， 其实 没有 肉 的 车 ， 只有 肉 的 人 ， 狠 得 下 心 去 踩 油门 那么 动力 还是 完全 满足 一般 使用 的 。
2 鹰眼 大灯 很漂亮 ， 感觉 挺 威猛 ， 但是 卤素大灯 是 硬伤 ， 其实 也 够用 。 车体 流线感 不错 ， 感觉 阳刚 又 不 失 锐气 ， 很 时尚 。 前脸 和 屁股 都是 很漂亮 ， 进气 栅 上 大大 的 LOGO 也 很 给力 ~
2 ： 操控 一流 ， 指向 精准 ， 路感 好 。
0 后排 空间 确实 是 小 啊 ， 老婆 和 小孩 坐 前面 ， 椅子 往后 挪 ， 后座 的 脚 就 很难 放 。
2 可以 的 。 我 又 不 比赛 ， 这点 够了 。 要 比赛 V12 去 啊 。 朋友 锐志 要 和 我 比 提速 我 还在 磨合期 等 过 了 比较 下 。
2 非常 满意 本人 1米 8多 体重 180斤 坐 里面 空间 有余 豪华版 电动 座椅 上下 前后 调节 很方便 后排 没 的 说 同 级别 最大 中级 车 的 后排 头部 空间 充足 驾驶 视线 很好 车身 高 的 缘故
2 油耗 7.3 左右 ， 市区 大概 8 - 9个 油 ， 高速 大概 6 - 7个 油 ， 0码 左右 油耗 大概 6个 油 ， 很好 ， 综合 起来 我 的 油耗 也 就 在 7个 多一点 了 ， 能 完全 接受 。
0 配件 质量 有待 提高 。
0 地盘 悬挂 比较 软 ， 颠簸 路面 容易 托底
0 低速 一般
1 漂亮 ， 大灯 偷工减料
2 有 ESP , 6 气囊 ， 性价比 高
2 这个 是 一大 优势 了 ， 空间 绝对 够塞 ， 后座 放下 后 简直 就是 一张 床 了 ， 一直 笑称 ： 一张 八仙桌 都 能 放 进去
1 就是 1.2档 起步 太 肉 ， 感觉 没 动力 ， 但是 一旦 速度 起来 了 ， 感觉 就是 爽 了 ， 3档 开始 无 压力
2 我 的 是 2.5G 的 ， 动力 绝对 够用 ， 抢 红绿灯 是 个 好手 ， 高速 上面 加速 比较 快 ， 一 踩 油门 轻松 到 120 .
2 转向 精准 ， 在 低速 状态 下 方向盘 助力 还是 很好 用 ， 方向 轻 ； 高速 状态 下 方向 助力 能 自动 调节 ， 避免 了 打 碎盘 或 路面 不平 带来 的 方向 摇晃 。
2 还在 观望 的 同学 赶紧 下手 吧 、 福克斯 绝对 是 你 值得 拥有 的 车型 、 还是 那句话 “ 早买 早 享受 ”
2 整车 质量 良好 ， 钢板 很 厚 ！
2 还不错 ， 真皮 座椅 软 硬度 适中 ， 隔音 效果 也 好 可以 ， 减震 效果 很好 ！ 空调 效果 也 行 ， 可惜 没有 后 排出 风口 ！ 音响效果 尚可 ， 原 车 导航 的 电视 功能 不错 ！
0 减震 太 硬 ， ， 过 起 伏路 硬帮帮 的
2 方向盘 转向 很 精确 ， 也 很舒服 ， 挡位 行程 很舒服 ， 挂挡 感觉 明显 ， 出现 过 1档 不好 挂 的 情况 ， ， 我 换 到 2档 再 到 1 挡 就好 了 ， ， 在 论坛 看到 有人 说 手动车 1档 倒档 不好 挂 是 正常 的 ？ 也 没 多大 影响 ， ， 现在 这样 也 很好 了
0 内饰 就 1般 了 硬 塑料 太多 ， 也不 精致 ， 不过 就 几W 的 车 你 也 不能 各方面 都 要求 那么 高
2 车 的 空间 比较 大 ， 操控 性能 很好 ， 特别 是 上 了 高速 以后 ， 车 很 稳 ， 同事 坐 了 我 的 车 大加 赞赏 啊 ， 车 得 用料 很 足 ， 感觉 很 厚重 ！
2 操控 很 灵敏 ， 方向 的 指向性 很好 ， 低速 很 轻 ， 高速 很 稳 ， 值得 赞赏 。
2 非常 大 ， 比 一般 的 轿车 空间 都 大 ， 而且 车身 偏高 ， 头部 空间 也 很 舒适
2 外观 漂亮 、 大气 ， 流线感 强 ， 运动 范 十足
0 黑色 内饰 ， 显得 空间 小 了 ， 还 显 灰 。 噪音 有点 大 ， 但 要 做 隔音 。 的 排 太 直 了 。
0 还行 ， 比 轿车 差点 ， 音响效果 中等 偏 上 ， 后排 空间 小 ， 比较 直 ， 对 我 来说 比较 压抑 。 从来 没 坐 过 。
1 低调 之 前 和 新 帕萨特 分 不 清 现在 不 细看 和 宝来朗逸 速腾 差 不 了 多少
1 中规中矩 大众 统一 的 内饰
2 舒适性 基本 可以 ， 性价比 已 不错 了 。
2 舒适性 感觉 还 可以
1 2.0 起步 也不 算 肉 ， 开 绿叶肉 点 。 但是 时速 过 90 ， 给 油 后 动力 输出 不足 。 当然 它 不是 2.0T , 这个 也 不能 苛求 ；
Senta/data/train.vocab 已删除 100755 → 0
浏览文件 @ 277aae4a
因为 它太大了无法显示 source diff 。你可以改为 查看blob。
Senta/data/train_data/corpus.train 已删除 100755 → 0
浏览文件 @ 277aae4a
因为 它太大了无法显示 source diff 。你可以改为 查看blob。
Senta/finetune.sh 已删除 100755 → 0
浏览文件 @ 277aae4a
python test_finetune.py --train_data_path ./data/train_data/corpus.train --word_dict_path ./data/train.vocab --mode train --model_path ./models
Senta/nets.py 已删除 100755 → 0
浏览文件 @ 277aae4a
import sys
import time
import numpy as np
import paddle.fluid as fluid
import paddle
import paddle_hub as hub
def bow_net(data,
label,
dict_dim,
emb_dim=128,
hid_dim=128,
hid_dim2=96,
class_dim=2):
"""
Bow net
"""
# embedding layer
emb = fluid.layers.embedding(
input=data, size=[dict_dim, emb_dim], param_attr="bow_embedding")
# bow layer
bow = fluid.layers.sequence_pool(input=emb, pool_type='sum')
bow_tanh = fluid.layers.tanh(bow)
# full connect layer
fc_1 = fluid.layers.fc(
input=bow_tanh, size=hid_dim, act="tanh", name="bow_fc1")
fc_2 = fluid.layers.fc(
input=fc_1, size=hid_dim2, act="tanh", name="bow_fc2")
# softmax layer
prediction = fluid.layers.fc(
input=[fc_2], size=class_dim, act="softmax", name="fc_softmax")
cost = fluid.layers.cross_entropy(input=prediction, label=label)
avg_cost = fluid.layers.mean(x=cost)
acc = fluid.layers.accuracy(input=prediction, label=label)
return avg_cost, acc, prediction, emb
def cnn_net(data,
label,
dict_dim,
emb_dim=128,
hid_dim=128,
hid_dim2=96,
class_dim=2,
win_size=3):
"""
Conv net
"""
# embedding layer
emb = fluid.layers.embedding(input=data, size=[dict_dim, emb_dim])
# convolution layer
conv_3 = fluid.nets.sequence_conv_pool(
input=emb,
num_filters=hid_dim,
filter_size=win_size,
act="tanh",
pool_type="max")
# full connect layer
fc_1 = fluid.layers.fc(input=[conv_3], size=hid_dim2)
# softmax layer
prediction = fluid.layers.fc(input=[fc_1], size=class_dim, act="softmax")
cost = fluid.layers.cross_entropy(input=prediction, label=label)
avg_cost = fluid.layers.mean(x=cost)
acc = fluid.layers.accuracy(input=prediction, label=label)
return avg_cost, acc, prediction
def lstm_net(data,
label,
dict_dim,
emb_dim=128,
hid_dim=128,
hid_dim2=96,
class_dim=2,
emb_lr=30.0):
"""
Lstm net
"""
# embedding layer
emb = fluid.layers.embedding(
input=data,
size=[dict_dim, emb_dim],
param_attr=fluid.ParamAttr(learning_rate=emb_lr))
# Lstm layer
fc0 = fluid.layers.fc(input=emb, size=hid_dim * 4)
lstm_h, c = fluid.layers.dynamic_lstm(
input=fc0, size=hid_dim * 4, is_reverse=False)
# max pooling layer
lstm_max = fluid.layers.sequence_pool(input=lstm_h, pool_type='max')
lstm_max_tanh = fluid.layers.tanh(lstm_max)
# full connect layer
fc1 = fluid.layers.fc(input=lstm_max_tanh, size=hid_dim2, act='tanh')
# softmax layer
prediction = fluid.layers.fc(input=fc1, size=class_dim, act='softmax')
cost = fluid.layers.cross_entropy(input=prediction, label=label)
avg_cost = fluid.layers.mean(x=cost)
acc = fluid.layers.accuracy(input=prediction, label=label)
return avg_cost, acc, prediction
def bilstm_net(data,
label,
dict_dim,
emb_dim=128,
hid_dim=128,
hid_dim2=96,
class_dim=2,
emb_lr=30.0):
"""
Bi-Lstm net
"""
# embedding layer
emb = fluid.layers.embedding(
input=data,
size=[dict_dim, emb_dim],
param_attr=fluid.ParamAttr(learning_rate=emb_lr))
# bi-lstm layer
fc0 = fluid.layers.fc(input=emb, size=hid_dim * 4)
rfc0 = fluid.layers.fc(input=emb, size=hid_dim * 4)
lstm_h, c = fluid.layers.dynamic_lstm(
input=fc0, size=hid_dim * 4, is_reverse=False)
rlstm_h, c = fluid.layers.dynamic_lstm(
input=rfc0, size=hid_dim * 4, is_reverse=True)
# extract last layer
lstm_last = fluid.layers.sequence_last_step(input=lstm_h)
rlstm_last = fluid.layers.sequence_last_step(input=rlstm_h)
lstm_last_tanh = fluid.layers.tanh(lstm_last)
rlstm_last_tanh = fluid.layers.tanh(rlstm_last)
# concat layer
lstm_concat = fluid.layers.concat(input=[lstm_last, rlstm_last], axis=1)
# full connect layer
fc1 = fluid.layers.fc(input=lstm_concat, size=hid_dim2, act='tanh')
# softmax layer
prediction = fluid.layers.fc(input=fc1, size=class_dim, act='softmax')
cost = fluid.layers.cross_entropy(input=prediction, label=label)
avg_cost = fluid.layers.mean(x=cost)
acc = fluid.layers.accuracy(input=prediction, label=label)
return avg_cost, acc, prediction
def gru_net(data,
label,
dict_dim,
emb_dim=128,
hid_dim=128,
hid_dim2=96,
class_dim=2,
emb_lr=30.0):
"""
gru net
"""
emb = fluid.layers.embedding(
input=data,
size=[dict_dim, emb_dim],
param_attr=fluid.ParamAttr(learning_rate=emb_lr))
fc0 = fluid.layers.fc(input=emb, size=hid_dim * 3)
gru_h = fluid.layers.dynamic_gru(input=fc0, size=hid_dim, is_reverse=False)
gru_max = fluid.layers.sequence_pool(input=gru_h, pool_type='max')
gru_max_tanh = fluid.layers.tanh(gru_max)
fc1 = fluid.layers.fc(input=gru_max_tanh, size=hid_dim2, act='tanh')
prediction = fluid.layers.fc(input=fc1, size=class_dim, act='softmax')
cost = fluid.layers.cross_entropy(input=prediction, label=label)
avg_cost = fluid.layers.mean(x=cost)
acc = fluid.layers.accuracy(input=prediction, label=label)
return avg_cost, acc, prediction
Senta/sentiment_classify.py 已删除 100755 → 0
浏览文件 @ 277aae4a
# coding: utf-8
import sys
import os
import time
import unittest
import contextlib
import logging
import argparse
import ast
import paddle.fluid as fluid
import paddle_hub as hub
import utils
from nets import bow_net
from nets import cnn_net
from nets import lstm_net
from nets import bilstm_net
from nets import gru_net
logger = logging.getLogger("paddle-fluid")
logger.setLevel(logging.INFO)
def parse_args():
parser = argparse.ArgumentParser("Sentiment Classification.")
# training data path
parser.add_argument(
"--train_data_path",
type=str,
required=False,
help="The path of trainning data. Should be given in train mode!")
# test data path
parser.add_argument(
"--test_data_path",
type=str,
required=False,
help="The path of test data. Should be given in eval or infer mode!")
# word_dict path
parser.add_argument(
"--word_dict_path",
type=str,
required=True,
help="The path of word dictionary.")
# current mode
parser.add_argument(
"--mode",
type=str,
required=True,
choices=['train', 'eval', 'infer'],
help="train/eval/infer mode")
# model type
parser.add_argument(
"--model_type", type=str, default="bow_net", help="type of model")
# model save path
parser.add_argument(
"--model_path",
type=str,
default="models",
required=True,
help="The path to saved the trained models.")
# Number of passes for the training task.
parser.add_argument(
"--num_passes",
type=int,
default=10,
help="Number of passes for the training task.")
# Batch size
parser.add_argument(
"--batch_size",
type=int,
default=256,
help="The number of training examples in one forward/backward pass.")
# lr value for training
parser.add_argument(
"--lr", type=float, default=0.002, help="The lr value for training.")
# Whether to use gpu
parser.add_argument(
"--use_gpu",
type=ast.literal_eval,
default=False,
help="Whether to use gpu to train the model.")
# parallel train
parser.add_argument(
"--is_parallel",
type=ast.literal_eval,
default=False,
help="Whether to train the model in parallel.")
args = parser.parse_args()
return args
def train_net(train_reader,
word_dict,
network_name,
use_gpu,
parallel,
save_dirname,
lr=0.002,
batch_size=128,
pass_num=30):
"""
train network
"""
if network_name == "bilstm_net":
network = bilstm_net
elif network_name == "bow_net":
network = bow_net
elif network_name == "cnn_net":
network = cnn_net
elif network_name == "lstm_net":
network = lstm_net
elif network_name == "gru_net":
network = gru_net
else:
print("unknown network type")
return
label = fluid.layers.data(name="label", shape=[1], dtype="int64")
data = fluid.layers.data(
name="words", shape=[1], dtype="int64", lod_level=1)
cost, acc, pred, emb = network(data, label, len(word_dict) + 2)
# set optimizer
sgd_optimizer = fluid.optimizer.Adagrad(learning_rate=lr)
sgd_optimizer.minimize(cost)
# set place, executor, datafeeder
place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
feeder = fluid.DataFeeder(feed_list=["words", "label"], place=place)
exe.run(fluid.default_startup_program())
# start training...
for pass_id in range(pass_num):
data_size, data_count, total_acc, total_cost = 0, 0, 0.0, 0.0
for batch in train_reader():
avg_cost_np, avg_acc_np = exe.run(
fluid.default_main_program(),
feed=feeder.feed(batch),
fetch_list=[cost, acc],
return_numpy=True)
data_size = len(batch)
total_acc += data_size * avg_acc_np
total_cost += data_size * avg_cost_np
data_count += data_size
avg_cost = total_cost / data_count
avg_acc = total_acc / data_count
print("[train info]: pass_id: %d, avg_acc: %f, avg_cost: %f" %
(pass_id, avg_acc, avg_cost))
# save the model
module_dir = os.path.join(save_dirname, network_name)
fluid.io.save_inference_model(module_dir, ["words"], emb, exe)
config = hub.ModuleConfig(module_dir)
config.save_dict(word_dict=word_dict)
config.dump()
def retrain_net(train_reader,
word_dict,
network_name,
use_gpu,
parallel,
save_dirname,
lr=0.002,
batch_size=128,
pass_num=30):
"""
train network
"""
if network_name == "bilstm_net":
network = bilstm_net
elif network_name == "bow_net":
network = bow_net
elif network_name == "cnn_net":
network = cnn_net
elif network_name == "lstm_net":
network = lstm_net
elif network_name == "gru_net":
network = gru_net
else:
print("unknown network type")
return
dict_dim = len(word_dict) + 2
emb_dim = 128
hid_dim = 128
hid_dim2 = 96
class_dim = 2
module_link = "./models/bow_net/"
module = hub.Module(module_link)
main_program = fluid.Program()
startup_program = fluid.Program()
# use switch program to test fine-tuning
fluid.framework.switch_main_program(module.get_inference_program())
# remove feed fetch operator and variable
ModuleUtils.remove_feed_fetch_op(fluid.default_main_program())
remove_feed_fetch_op(fluid.default_main_program())
label = fluid.layers.data(name="label", shape=[1], dtype="int64")
data = fluid.default_main_program().global_block().var("words")
#TODO(ZeyuChen): how to get output paramter according to proto config
emb = module.get_module_output()
# # embedding layer
# emb = fluid.layers.embedding(input=data, size=[dict_dim, emb_dim])
# #input=data, size=[dict_dim, emb_dim], param_attr="bow_embedding")
# # bow layer
bow = fluid.layers.sequence_pool(input=emb, pool_type='sum')
bow_tanh = fluid.layers.tanh(bow)
# full connect layer
fc_1 = fluid.layers.fc(
input=bow_tanh, size=hid_dim, act="tanh", name="bow_fc1")
fc_2 = fluid.layers.fc(
input=fc_1, size=hid_dim2, act="tanh", name="bow_fc2")
# softmax layer
pred = fluid.layers.fc(input=[fc_2], size=class_dim, act="softmax")
# print(fluid.default_main_program())
cost = fluid.layers.mean(
fluid.layers.cross_entropy(input=pred, label=label))
acc = fluid.layers.accuracy(input=pred, label=label)
# set optimizer
sgd_optimizer = fluid.optimizer.Adagrad(learning_rate=lr)
sgd_optimizer.minimize(cost)
# set place, executor, datafeeder
place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
feeder = fluid.DataFeeder(feed_list=["words", "label"], place=place)
exe.run(fluid.default_startup_program())
# start training...
for pass_id in range(pass_num):
data_size, data_count, total_acc, total_cost = 0, 0, 0.0, 0.0
for batch in train_reader():
avg_cost_np, avg_acc_np = exe.run(
fluid.default_main_program(),
feed=feeder.feed(batch),
fetch_list=[cost, acc],
return_numpy=True)
data_size = len(batch)
total_acc += data_size * avg_acc_np
total_cost += data_size * avg_cost_np
data_count += data_size
avg_cost = total_cost / data_count
avg_acc = total_acc / data_count
print("[train info]: pass_id: %d, avg_acc: %f, avg_cost: %f" %
(pass_id, avg_acc, avg_cost))
# compare program desc here when we change the graph
with open("senta_forward_backward_module.prototxt", "w") as fo:
fo.write(str(fluid.default_main_program()))
# print("senta_load_module", fluid.default_main_program())
# save the model
module_dir = os.path.join(save_dirname, network_name + "_retrain")
fluid.io.save_inference_model(module_dir, ["words"], emb, exe)
def eval_net(test_reader, use_gpu, model_path=None):
"""
Evaluation function
"""
if model_path is None:
print(str(model_path) + "can not be found")
return
# set place, executor
place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
inference_scope = fluid.core.Scope()
with fluid.scope_guard(inference_scope):
# load the saved model
[inference_program, feed_target_names,
fetch_targets] = fluid.io.load_inference_model(model_path, exe)
# compute 2class and 3class accuracy
class2_acc, class3_acc = 0.0, 0.0
total_count, neu_count = 0, 0
for data in test_reader():
# infer a batch
pred = exe.run(
inference_program,
feed=utils.data2tensor(data, place),
fetch_list=fetch_targets,
return_numpy=True)
for i, val in enumerate(data):
class3_label, class2_label = utils.get_predict_label(
pred[0][i, 1])
true_label = val[1]
if class2_label == true_label:
class2_acc += 1
if class3_label == true_label:
class3_acc += 1
if true_label == 1.0:
neu_count += 1
total_count += len(data)
class2_acc = class2_acc / (total_count - neu_count)
class3_acc = class3_acc / total_count
print("[test info] model_path: %s, class2_acc: %f, class3_acc: %f" %
(model_path, class2_acc, class3_acc))
def infer_net(test_reader, use_gpu, model_path=None):
"""
Inference function
"""
if model_path is None:
print(str(model_path) + "can not be found")
return
# set place, executor
place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
inference_scope = fluid.core.Scope()
with fluid.scope_guard(inference_scope):
# load the saved model
[inference_program, feed_target_names,
fetch_targets] = fluid.io.load_inference_model(model_path, exe)
for data in test_reader():
# infer a batch
pred = exe.run(
inference_program,
feed=utils.data2tensor(data, place),
fetch_list=fetch_targets,
return_numpy=True)
for i, val in enumerate(data):
class3_label, class2_label = utils.get_predict_label(
pred[0][i, 1])
pos_prob = pred[0][i, 1]
neg_prob = 1 - pos_prob
print("predict label: %d, pos_prob: %f, neg_prob: %f" %
(class3_label, pos_prob, neg_prob))
def main(args):
# train mode
if args.mode == "train":
# prepare_data to get word_dict, train_reader
word_dict, train_reader = utils.prepare_data(args.train_data_path,
args.word_dict_path,
args.batch_size, args.mode)
train_net(train_reader, word_dict, args.model_type, args.use_gpu,
args.is_parallel, args.model_path, args.lr, args.batch_size,
args.num_passes)
# eval mode
elif args.mode == "eval":
# prepare_data to get word_dict, test_reader
word_dict, test_reader = utils.prepare_data(args.test_data_path,
args.word_dict_path,
args.batch_size, args.mode)
eval_net(test_reader, args.use_gpu, args.model_path)
# infer mode
elif args.mode == "infer":
# prepare_data to get word_dict, test_reader
word_dict, test_reader = utils.prepare_data(args.test_data_path,
args.word_dict_path,
args.batch_size, args.mode)
infer_net(test_reader, args.use_gpu, args.model_path)
if __name__ == "__main__":
args = parse_args()
main(args)
Senta/test_create_module.py 已删除 100755 → 0
浏览文件 @ 277aae4a
# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# coding: utf-8
import sys
import os
import time
import unittest
import contextlib
import logging
import argparse
import ast
import utils
import paddle.fluid as fluid
import paddle_hub as hub
from nets import bow_net
from nets import cnn_net
from nets import lstm_net
from nets import bilstm_net
from nets import gru_net
logger = logging.getLogger("paddle-fluid")
logger.setLevel(logging.INFO)
def parse_args():
parser = argparse.ArgumentParser("Sentiment Classification.")
# training data path
parser.add_argument(
"--train_data_path",
type=str,
required=False,
help="The path of trainning data. Should be given in train mode!")
# test data path
parser.add_argument(
"--test_data_path",
type=str,
required=False,
help="The path of test data. Should be given in eval or infer mode!")
# word_dict path
parser.add_argument(
"--word_dict_path",
type=str,
required=True,
help="The path of word dictionary.")
# current mode
parser.add_argument(
"--mode",
type=str,
required=True,
choices=['train', 'eval', 'infer'],
help="train/eval/infer mode")
# model type
parser.add_argument(
"--model_type", type=str, default="bow_net", help="type of model")
# model save path parser.add_argument(
parser.add_argument(
"--model_path",
type=str,
default="models",
required=True,
help="The path to saved the trained models.")
# Number of passes for the training task.
parser.add_argument(
"--num_passes",
type=int,
default=3,
help="Number of passes for the training task.")
# Batch size
parser.add_argument(
"--batch_size",
type=int,
default=256,
help="The number of training examples in one forward/backward pass.")
# lr value for training
parser.add_argument(
"--lr", type=float, default=0.002, help="The lr value for training.")
# Whether to use gpu
parser.add_argument(
"--use_gpu",
type=ast.literal_eval,
default=False,
help="Whether to use gpu to train the model.")
# parallel train
parser.add_argument(
"--is_parallel",
type=ast.literal_eval,
default=False,
help="Whether to train the model in parallel.")
args = parser.parse_args()
return args
def bow_net_module(data,
label,
dict_dim,
emb_dim=128,
hid_dim=128,
hid_dim2=96,
class_dim=2):
"""
Bow net
"""
module_dir = "./model/test_create_module"
# embedding layer
emb = fluid.layers.embedding(
input=data, size=[dict_dim, emb_dim], param_attr="bow_embedding")
# bow layer
bow = fluid.layers.sequence_pool(input=emb, pool_type='sum')
bow_tanh = fluid.layers.tanh(bow)
# full connect layer
fc_1 = fluid.layers.fc(
input=bow_tanh, size=hid_dim, act="tanh", name="bow_fc1")
fc_2 = fluid.layers.fc(
input=fc_1, size=hid_dim2, act="tanh", name="bow_fc2")
# softmax layer
prediction = fluid.layers.fc(
input=[fc_2], size=class_dim, act="softmax", name="fc_softmax")
cost = fluid.layers.cross_entropy(input=prediction, label=label)
avg_cost = fluid.layers.mean(x=cost)
acc = fluid.layers.accuracy(input=prediction, label=label)
return avg_cost, acc, prediction, emb
def train_net(train_reader,
word_dict,
network_name,
use_gpu,
parallel,
save_dirname,
lr=0.002,
batch_size=128,
pass_num=10):
"""
train network
"""
if network_name == "bilstm_net":
network = bilstm_net
elif network_name == "bow_net":
network = bow_net
elif network_name == "cnn_net":
network = cnn_net
elif network_name == "lstm_net":
network = lstm_net
elif network_name == "gru_net":
network = gru_net
else:
print("unknown network type")
return
label = fluid.layers.data(name="label", shape=[1], dtype="int64")
data = fluid.layers.data(
name="words", shape=[1], dtype="int64", lod_level=1)
cost, acc, pred, emb = network(data, label, len(word_dict) + 2)
# set optimizer
sgd_optimizer = fluid.optimizer.Adagrad(learning_rate=lr)
sgd_optimizer.minimize(cost)
# set place, executor, datafeeder
place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
feeder = fluid.DataFeeder(feed_list=["words", "label"], place=place)
exe.run(fluid.default_startup_program())
# start training...
for pass_id in range(pass_num):
data_size, data_count, total_acc, total_cost = 0, 0, 0.0, 0.0
for batch in train_reader():
avg_cost_np, avg_acc_np = exe.run(
fluid.default_main_program(),
feed=feeder.feed(batch),
fetch_list=[cost, acc],
return_numpy=True)
data_size = len(batch)
total_acc += data_size * avg_acc_np
total_cost += data_size * avg_cost_np
data_count += data_size
avg_cost = total_cost / data_count
avg_acc = total_acc / data_count
print("[train info]: pass_id: %d, avg_acc: %f, avg_cost: %f" %
(pass_id, avg_acc, avg_cost))
# save the model
module_dir = os.path.join(save_dirname, network_name)
config = hub.ModuleConfig(module_dir)
config.save_dict(word_dict=word_dict)
# saving config
input_desc = {"words": data.name}
output_desc = {"emb": emb.name}
config.register_feed_signature(input_desc)
config.register_fetch_signature(output_desc)
config.dump()
feed_var_name = config.feed_var_name("words")
fluid.io.save_inference_model(module_dir, [feed_var_name], emb, exe)
def retrain_net(train_reader,
word_dict,
network_name,
use_gpu,
parallel,
save_dirname,
lr=0.002,
batch_size=128,
pass_num=30):
"""
train network
"""
if network_name == "bilstm_net":
network = bilstm_net
elif network_name == "bow_net":
network = bow_net
elif network_name == "cnn_net":
network = cnn_net
elif network_name == "lstm_net":
network = lstm_net
elif network_name == "gru_net":
network = gru_net
else:
print("unknown network type")
return
dict_dim = len(word_dict) + 2
emb_dim = 128
hid_dim = 128
hid_dim2 = 96
class_dim = 2
module_path = "./models/bow_net"
module = hub.Module(module_dir=module_path)
main_program = fluid.Program()
startup_program = fluid.Program()
# use switch program to test fine-tuning
fluid.framework.switch_main_program(module.get_inference_program())
# remove feed fetch operator and variable
hub.ModuleUtils.remove_feed_fetch_op(fluid.default_main_program())
label = fluid.layers.data(name="label", shape=[1], dtype="int64")
data = module.get_feed_var("words")
emb = module.get_fetch_var("emb")
# bow layer
bow = fluid.layers.sequence_pool(input=emb, pool_type='sum')
bow_tanh = fluid.layers.tanh(bow)
# full connect layer
fc_1 = fluid.layers.fc(
input=bow_tanh, size=hid_dim, act="tanh", name="bow_fc1")
fc_2 = fluid.layers.fc(
input=fc_1, size=hid_dim2, act="tanh", name="bow_fc2")
# softmax layer
pred = fluid.layers.fc(input=[fc_2], size=class_dim, act="softmax")
cost = fluid.layers.mean(
fluid.layers.cross_entropy(input=pred, label=label))
acc = fluid.layers.accuracy(input=pred, label=label)
# set optimizer
sgd_optimizer = fluid.optimizer.Adagrad(learning_rate=lr)
sgd_optimizer.minimize(cost)
# set place, executor, datafeeder
place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
feeder = fluid.DataFeeder(feed_list=["words", "label"], place=place)
exe.run(fluid.default_startup_program())
# start training...
for pass_id in range(pass_num):
data_size, data_count, total_acc, total_cost = 0, 0, 0.0, 0.0
for batch in train_reader():
avg_cost_np, avg_acc_np = exe.run(
fluid.default_main_program(),
feed=feeder.feed(batch),
fetch_list=[cost, acc],
return_numpy=True)
data_size = len(batch)
total_acc += data_size * avg_acc_np
total_cost += data_size * avg_cost_np
data_count += data_size
avg_cost = total_cost / data_count
avg_acc = total_acc / data_count
print("[train info]: pass_id: %d, avg_acc: %f, avg_cost: %f" %
(pass_id, avg_acc, avg_cost))
# save the model
module_dir = os.path.join(save_dirname, network_name + "_retrain")
fluid.io.save_inference_model(module_dir, ["words"], emb, exe)
config = hub.ModuleConfig(module_dir)
config.save_dict(word_dict=word_dict)
config.dump()
def main(args):
# prepare_data to get word_dict, train_reader
word_dict, train_reader = utils.prepare_data(
args.train_data_path, args.word_dict_path, args.batch_size, args.mode)
train_net(train_reader, word_dict, args.model_type, args.use_gpu,
args.is_parallel, args.model_path, args.lr, args.batch_size,
args.num_passes)
# NOTE(ZeyuChen): can't run train_net and retrain_net together
# retrain_net(train_reader, word_dict, args.model_type, args.use_gpu,
# args.is_parallel, args.model_path, args.lr, args.batch_size,
# args.num_passes)
if __name__ == "__main__":
args = parse_args()
main(args)
Senta/test_finetune.py 已删除 100755 → 0
浏览文件 @ 277aae4a
# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# coding: utf-8
import sys
import os
import time
import unittest
import contextlib
import logging
import argparse
import ast
import utils
import paddle.fluid as fluid
import paddle_hub as hub
from nets import bow_net
from nets import cnn_net
from nets import lstm_net
from nets import bilstm_net
from nets import gru_net
logger = logging.getLogger("paddle-fluid")
logger.setLevel(logging.INFO)
def parse_args():
parser = argparse.ArgumentParser("Sentiment Classification.")
# training data path
parser.add_argument(
"--train_data_path",
type=str,
required=False,
help="The path of trainning data. Should be given in train mode!")
# test data path
parser.add_argument(
"--test_data_path",
type=str,
required=False,
help="The path of test data. Should be given in eval or infer mode!")
# word_dict path
parser.add_argument(
"--word_dict_path",
type=str,
required=True,
help="The path of word dictionary.")
# current mode
parser.add_argument(
"--mode",
type=str,
required=True,
choices=['train', 'eval', 'infer'],
help="train/eval/infer mode")
# model type
parser.add_argument(
"--model_type", type=str, default="bow_net", help="type of model")
# model save path
parser.add_argument(
"--model_path",
type=str,
default="models",
required=True,
help="The path to saved the trained models.")
# Number of passes for the training task.
parser.add_argument(
"--num_passes",
type=int,
default=10,
help="Number of passes for the training task.")
# Batch size
parser.add_argument(
"--batch_size",
type=int,
default=256,
help="The number of training examples in one forward/backward pass.")
# lr value for training
parser.add_argument(
"--lr", type=float, default=0.002, help="The lr value for training.")
# Whether to use gpu
parser.add_argument(
"--use_gpu",
type=ast.literal_eval,
default=False,
help="Whether to use gpu to train the model.")
# parallel train
parser.add_argument(
"--is_parallel",
type=ast.literal_eval,
default=False,
help="Whether to train the model in parallel.")
args = parser.parse_args()
return args
def retrain_net(train_reader,
word_dict,
network_name,
use_gpu,
parallel,
save_dirname,
lr=0.002,
batch_size=128,
pass_num=30):
"""
train network
"""
if network_name == "bilstm_net":
network = bilstm_net
elif network_name == "bow_net":
network = bow_net
elif network_name == "cnn_net":
network = cnn_net
elif network_name == "lstm_net":
network = lstm_net
elif network_name == "gru_net":
network = gru_net
else:
print("unknown network type")
return
dict_dim = len(word_dict) + 2
emb_dim = 128
hid_dim = 128
hid_dim2 = 96
class_dim = 2
module_path = "./models/bow_net"
module = hub.Module(module_dir=module_path)
main_program = fluid.Program()
startup_program = fluid.Program()
# use switch program to test fine-tuning
fluid.framework.switch_main_program(module.get_inference_program())
# remove feed fetch operator and variable
hub.ModuleUtils.remove_feed_fetch_op(fluid.default_main_program())
# remove_feed_fetch_op(fluid.default_main_program())
label = fluid.layers.data(name="label", shape=[1], dtype="int64")
#data = fluid.default_main_program().global_block().var("words")
data = module.get_feed_var("words")
#TODO(ZeyuChen): how to get output paramter according to proto config
emb = module.get_fetch_var("emb")
# # # embedding layer
# emb = fluid.layers.embedding(input=data, size=[dict_dim, emb_dim])
# #input=data, size=[dict_dim, emb_dim], param_attr="bow_embedding")
# # bow layer
bow = fluid.layers.sequence_pool(input=emb, pool_type='sum')
bow_tanh = fluid.layers.tanh(bow)
# full connect layer
fc_1 = fluid.layers.fc(
input=bow_tanh, size=hid_dim, act="tanh", name="bow_fc1")
fc_2 = fluid.layers.fc(
input=fc_1, size=hid_dim2, act="tanh", name="bow_fc2")
# softmax layer
pred = fluid.layers.fc(input=[fc_2], size=class_dim, act="softmax")
# print(fluid.default_main_program())
cost = fluid.layers.mean(
fluid.layers.cross_entropy(input=pred, label=label))
acc = fluid.layers.accuracy(input=pred, label=label)
# set optimizer
sgd_optimizer = fluid.optimizer.Adagrad(learning_rate=lr)
sgd_optimizer.minimize(cost)
# set place, executor, datafeeder
place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
feeder = fluid.DataFeeder(feed_list=["words", "label"], place=place)
exe.run(fluid.default_startup_program())
# start training...
for pass_id in range(pass_num):
data_size, data_count, total_acc, total_cost = 0, 0, 0.0, 0.0
for batch in train_reader():
avg_cost_np, avg_acc_np = exe.run(
fluid.default_main_program(),
feed=feeder.feed(batch),
fetch_list=[cost, acc],
return_numpy=True)
data_size = len(batch)
total_acc += data_size * avg_acc_np
total_cost += data_size * avg_cost_np
data_count += data_size
avg_cost = total_cost / data_count
avg_acc = total_acc / data_count
print("[train info]: pass_id: %d, avg_acc: %f, avg_cost: %f" %
(pass_id, avg_acc, avg_cost))
# save the model
module_dir = os.path.join(save_dirname, network_name + "_retrain")
fluid.io.save_inference_model(module_dir, ["words"], emb, exe)
input_desc = {"words": data.name}
output_desc = {"emb": emb.name}
config = hub.ModuleConfig(module_dir)
config.save_dict(word_dict=word_dict)
config.dump()
def main(args):
# prepare_data to get word_dict, train_reader
word_dict, train_reader = utils.prepare_data(
args.train_data_path, args.word_dict_path, args.batch_size, args.mode)
retrain_net(train_reader, word_dict, args.model_type, args.use_gpu,
args.is_parallel, args.model_path, args.lr, args.batch_size,
args.num_passes)
if __name__ == "__main__":
args = parse_args()
main(args)
Senta/train.sh 已删除 100755 → 0
浏览文件 @ 277aae4a
python sentiment_classify.py --train_data_path ./data/train_data/corpus.train --word_dict_path ./data/train.vocab --mode train --model_path ./models
Senta/utils.py 已删除 100755 → 0
浏览文件 @ 277aae4a
import os
import sys
import time
import numpy as np
import random
import paddle.fluid as fluid
import paddle
def get_predict_label(pos_prob):
neg_prob = 1 - pos_prob
# threshold should be (1, 0.5)
neu_threshold = 0.55
if neg_prob > neu_threshold:
class3_label = 0
elif pos_prob > neu_threshold:
class3_label = 2
else:
class3_label = 1
if pos_prob >= neg_prob:
class2_label = 2
else:
class2_label = 0
return class3_label, class2_label
def to_lodtensor(data, place):
"""
convert ot LODtensor
"""
seq_lens = [len(seq) for seq in data]
cur_len = 0
lod = [cur_len]
for l in seq_lens:
cur_len += l
lod.append(cur_len)
flattened_data = np.concatenate(data, axis=0).astype("int64")
flattened_data = flattened_data.reshape([len(flattened_data), 1])
res = fluid.LoDTensor()
res.set(flattened_data, place)
res.set_lod([lod])
return res
def data2tensor(data, place):
"""
data2tensor
"""
input_seq = to_lodtensor(map(lambda x: x[0], data), place)
return {"words": input_seq}
def data_reader(file_path, word_dict, is_shuffle=True):
"""
Convert word sequence into slot
"""
unk_id = len(word_dict)
all_data = []
with open(file_path, "r") as fin:
for line in fin:
cols = line.strip().split("\t")
label = int(cols[0])
wids = [
word_dict[x] if x in word_dict else unk_id
for x in cols[1].split(" ")
]
all_data.append((wids, label))
if is_shuffle:
random.shuffle(all_data)
def reader():
for doc, label in all_data:
yield doc, label
return reader
def load_vocab(file_path):
"""
load the given vocabulary
"""
vocab = {}
with open(file_path) as f:
wid = 0
for line in f:
vocab[line.strip()] = wid
wid += 1
vocab["<unk>"] = len(vocab)
return vocab
def prepare_data(data_path, word_dict_path, batch_size, mode):
"""
prepare data
"""
assert os.path.exists(
word_dict_path), "The given word dictionary dose not exist."
if mode == "train":
assert os.path.exists(
data_path), "The given training data does not exist."
if mode == "eval" or mode == "infer":
assert os.path.exists(data_path), "The given test data does not exist."
word_dict = load_vocab(word_dict_path)
if mode == "train":
train_reader = paddle.batch(
data_reader(data_path, word_dict, True), batch_size)
return word_dict, train_reader
else:
test_reader = paddle.batch(
data_reader(data_path, word_dict, False), batch_size)
return word_dict, test_reader
paddle_hub/module.py
浏览文件 @ a00bc6a9
......@@ -65,10 +65,12 @@ class Module(object):
# load paddle inference model
place = fluid.CPUPlace()
model_dir = os.path.join(self.module_dir, "model")
print("model_dir", model_dir)
self.exe = fluid.Executor(fluid.CPUPlace())
[self.inference_program, self.feed_target_names,
self.fetch_targets] = fluid.io.load_inference_model(
dirname=self.module_dir, executor=self.exe)
dirname=model_dir, executor=self.exe)
print("inference_program")
print(self.inference_program)
......@@ -128,6 +130,54 @@ class Module(object):
raise Exception("Can't find input var {}".format(key))
def get_feed_var_by_index(self, index, signature="default"):
feed_vars = self.get_feed_vars(signature)
assert index < len(
feed_vars), "index out of range index {}, len {}".format(
index, len(feed_vars))
return feed_vars[index]
def get_fetch_var_by_index(self, index, signature="default"):
fetch_vars = self.get_fetch_vars(signature)
assert index < len(
fetch_vars), "index out of range index {}, len {}".format(
index, len(fetch_vars))
return fetch_vars[index]
def get_feed_vars(self, signature="default"):
"""
Get feed variable according to variable key and signature
"""
feed_vars = []
for feed_var in self.config.feed_var_names(signature):
find_var = False
for var in self.inference_program.list_vars():
if var.name == feed_var.var_name:
feed_vars.append(var)
find_var = True
if not find_var:
raise Exception("Can't find feed var {}".format(feed_var_name))
return feed_vars
def get_fetch_vars(self, signature="default"):
"""
Get feed variable according to variable key and signature
"""
fetch_vars = []
#TODO(ZeyuChen): use brute force to find variables, simple and easy to
#understand
for fetch_var in self.config.fetch_var_names(signature):
find_var = False
for var in self.inference_program.list_vars():
if var.name == fetch_var.var_name:
fetch_vars.append(var)
find_var = True
if not find_var:
raise Exception("Can't find feed var {}".format(fetch_var_name))
return fetch_vars
def get_fetch_var(self, key, signature="default"):
"""
Get fetch variable according to variable key and signature
......@@ -136,8 +186,6 @@ class Module(object):
if var.name == self.config.fetch_var_name(key, signature):
return var
raise Exception("Can't find output var {}".format(key))
def get_inference_program(self):
return self.inference_program
......@@ -202,6 +250,9 @@ class ModuleConfig(object):
with open(pb_path, "rb") as fi:
self.desc.ParseFromString(fi.read())
print("self.desc.sign2var",
self.desc.sign2var["default"].feed_desc[0].var_name)
if self.desc.contain_assets:
# load assets
assets_dir = os.path.join(self.module_dir, ASSETS_NAME)
......@@ -267,6 +318,12 @@ class ModuleConfig(object):
fetch.key = k
fetch.var_name = fetch_desc[k]
def feed_var_names(self, sign_name="default"):
return self.desc.sign2var[sign_name].feed_desc
def fetch_var_names(self, sign_name="default"):
return self.desc.sign2var[sign_name].fetch_desc
def feed_var_name(self, key, sign_name="default"):
"""get module's feed/input variable name
"""
......
paddle_hub/module_creator.py
浏览文件 @ a00bc6a9
......@@ -76,7 +76,7 @@ def create_module(sign_arr, program, path=None, assets=None):
# save inference program
exe = fluid.Executor(place=fluid.CPUPlace())
model_path = os.path.join(path, "model")
os.makedirs(model_path)
mkdir(model_path)
first_sign = sign_arr[0]
fluid.io.save_inference_model(
model_path,
......@@ -84,7 +84,7 @@ def create_module(sign_arr, program, path=None, assets=None):
target_vars=first_sign.get_outputs(),
executor=exe)
# save to dist
# save to disk
data = module.SerializeToString()
metafile = os.path.join(path, "module_desc.pb")
with open(metafile, "wb") as f:
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或