├── Parameters.txt ├── README.md ├── data_test ├── TestCorpus_gold_16.seg.txt ├── TrainingCorpus_16.seg.txt └── devCorpus_16.seg.txt ├── eval.py ├── hyperparams.py ├── loaddata ├── Alphabet.py ├── Batch_Iterator.py ├── Dataloader.py ├── Dataloader_normal.py ├── Instance.py ├── Load_external_word_embedding.py ├── Load_pretrain.py ├── __pycache__ │ ├── Alphabet.cpython-36.pyc │ ├── Batch_Iterator.cpython-36.pyc │ ├── Dataloader.cpython-36.pyc │ ├── Instance.cpython-36.pyc │ ├── Load_external_word_embedding.cpython-36.pyc │ └── common.cpython-36.pyc ├── common.py └── handle_wordEmbedding2File.py ├── main_hyperparams.py ├── models ├── __pycache__ │ ├── decoder_wordlstm_batch.cpython-36.pyc │ ├── encoder_wordlstm.cpython-36.pyc │ └── encoder_wordlstmcell.cpython-36.pyc ├── decoder_wordlstm_batch.py ├── encoder_wordlstm.py └── encoder_wordlstmcell.py ├── pytorch.py ├── run.sh ├── state.py ├── temp_data.txt ├── train_seq2seq_wordlstm_batch.py └── word_embedding └── README.md /Parameters.txt: -------------------------------------------------------------------------------- 1 | ADADELTA=False 2 | ADAM=True 3 | ENCODER_LSTM=False 4 | ENCODER_LSTMCELL=True 5 | SGD=False 6 | WORDLSTM=True 7 | BATCH_SIZE=16 8 | BICHAR_EMBEDDING=False 9 | BICHAR_EMBEDDING_PATH=./word_embedding/bichar-small.vec 10 | BICHAR_MIN_FREQ=2 11 | CHAR_EMBEDDING=False 12 | CHAR_EMBEDDING_PATH=./word_embedding/char.vec 13 | CHAR_MIN_FREQ=2 14 | CREATE_ALPHABET= 15 | CREATE_STATIC_ALPHABET= 16 | DEV_BATCH_SIZE=16 17 | DEV_INTERVAL=4000000 18 | DEV_PATH=./data_test/devCorpus_16.seg.txt 19 | DROPOUT=0.25 20 | DROPOUT_EMBED=0.25 21 | DROPOUT_LSTM=0.5 22 | EMBED_BICHAR_DIM=200 23 | EMBED_BICHAR_NUM=220 24 | EMBED_CHAR_DIM=200 25 | EMBED_CHAR_NUM=267 26 | EMBED_DIM=300 27 | EPOCHS=200 28 | EPOCHS_SHUFFLE=True 29 | FIX_EMBEDDING=False 30 | GPU_DEVICE=0 31 | HIDDEN_SIZE=200 32 | INIT_CLIP_MAX_NORM=10 33 | INIT_WEIGHT=True 34 | INIT_WEIGHT_DECAY=1e-08 35 | INIT_WEIGHT_VALUE=6.0 36 | LABEL_SIZE=2 37 | LEARNING_RATE_DECAY=1 38 | LOG_INTERVAL=1 39 | LR=0.001 40 | MAX_NORM=None 41 | MIN_FREQ=1 42 | MOMENTUM_VALUE=0.9 43 | MULU=2017-12-13_16-28-44 44 | NUM_THREADS=1 45 | POS_DIM=100 46 | POS_SIZE=3 47 | RM_MODEL=True 48 | RNN_HIDDEN_DIM=200 49 | RNN_NUM_LAYERS=1 50 | SAVE_DIR=snapshot\2017-12-13_16-28-44 51 | SEED_NUM=233 52 | SHUFFLE=False 53 | STATIC=False 54 | STATIC_EMBED_BICHAR_NUM=2808 55 | STATIC_EMBED_CHAR_NUM=721 56 | TEST_BATCH_SIZE=16 57 | TEST_INTERVAL=4000000 58 | TEST_PATH=./data_test/TestCorpus_gold_16.seg.txt 59 | TRAIN_PATH=./data_test/TrainingCorpus_16.seg.txt 60 | USE_CUDA=False 61 | WORD_EMBEDDING=True 62 | WORD_EMBEDDING_PATH=./word2vec/glove.sentiment.conj.pretrained.txt 63 | WORD_MIN_FREQ=1 64 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ## Introduction 2 | pytorch implement Chinese Word Segmentation and POS Tagging using seq2seq model 3 | 4 | ## Requirement 5 | * python 3 6 | * pytorch > 0.1(I used pytorch 0.2.0 and 0.3.0) 7 | * numpy 8 | 9 | ## Performance Result 10 | update later 11 | 12 | ## Data 13 | CTB6.0 14 | 15 | ## How to run 16 | "python main-hyperparams.py" or "bash run.sh" 17 | 18 | 19 | ## How to use the folder or file 20 | 21 | - the file of **`hyperparams.py`** contains all hyperparams that need to modify, based on yours nedds, select neural networks what you want and config the hyperparams. 22 | 23 | - the file of **`main-hyperparams.py`** is the main function,run the command ("python main_hyperparams.py") to execute the demo. 24 | 25 | - the folder of **`models`** contains encoder model and decoder model. 26 | 27 | - the file of **`train_seq2seq_wordlstm_batch.py`** is the train function about batch decoder(fast speed) 28 | 29 | - the file of **`train_seq2seq_wordlstm_nobatch.py`** is the train function about no use batch(low speed) 30 | 31 | - the file of **`eval.py`** is the eval function about calculate F-score 32 | 33 | - the folder of **`loaddata`** contains some file of load dataset 34 | 35 | ''' 36 | 1、Dataloader.py --- loading sorted data by sentence length 37 | 2、Dataloader_normal.py --- loading data by order 38 | 3、Batch_Iterator.py --- create batch and iterator 39 | 4、Alphabet.py --- cerate alphabet by data 40 | 5、Load_external_word_embedding.py --- load pretrained word embedding 41 | ''' 42 | 43 | - the folder of **`word_embedding`** is the file of word embedding that have pretrained you want to use 44 | 45 | - the folder of **`pos_test_data`** contains the dataset file, dataset is `CTB6.0` 46 | 47 | - the file of **`Parameters.txt`** is being used to save all parameters values. 48 | 49 | 50 | ## How to use the Word Embedding in demo? 51 | 52 | - the word embedding file saved in the folder of **word_embedding**, but now is empty, because of it is to big,so if you want to use word embedding,you can to download word2vec or glove file, then saved in the folder of word_embedding,and make the option of xxx-Embedding to True and modifiy the value of xxx-Embedding_Path in the **hyperparams.py** file. 53 | 54 | 55 | ## Neural Networks 56 | 57 | seq2seq model 58 | 59 | ## How to config hyperparams in the file of hyperparams.py 60 | 61 | - **learning_rate**: initial learning rate. 62 | 63 | - **learning_rate_decay**: change the learning rate for optim. 64 | 65 | - **epochs**:number of epochs for train 66 | 67 | - **train-batch-size、dev-batch-size、test-batch-size**：batch size for train、dev、test 68 | 69 | - **log_interval**：how many steps to wait before logging training status 70 | 71 | - **test_interval**：how many steps to wait before testing 72 | 73 | - **dev_interval**：how many steps to wait before dev 74 | 75 | - **save_dir**：where to save the snapshot 76 | 77 | - **train_path、dev-path、test-path**：datafile path 78 | 79 | - **shuffle**:whether to shuffle the dataset when readed dataset 80 | 81 | - **dropout**:the probability for dropout 82 | 83 | - **max_norm**:l2 constraint of parameters 84 | 85 | - **clip-max-norm**:the values of prevent the explosion and Vanishing in Gradient 86 | 87 | - **Adam**:select the optimizer of adam 88 | 89 | - **SGD**：select the optimizer of SGD 90 | 91 | - **Adadelta**:select the optimizer of Adadelta 92 | 93 | - **optim-momentum-value**:the parameter in the optimizer 94 | 95 | - **xxx-min-freq**:min freq to include during built the vocab 96 | 97 | - **xxx-Embedding**: use word embedding 98 | 99 | - **fix-Embedding**: use word embedding if to fix during trainging 100 | 101 | - **embed-dim、embed-xxx-dim**:number of embedding dimension 102 | 103 | - **xxx-Embedding-Path**:the path of word embedding file 104 | 105 | - **num-layers**:the num of layers with lstm 106 | 107 | - **use-cuda**: use cuda 108 | 109 | - **num_threads**:set the value of threads when run the demo 110 | 111 | - **init_weight**:whether to init weight 112 | 113 | - **init-weight-value**:the value of init weight 114 | 115 | - **weight-decay**:L2 weight_decay,default value is zero in optimizer 116 | 117 | - **seed_num**:set the num of random seed 118 | 119 | - **rm-model**:whether to delete the model after test acc so that to save space 120 | 121 | 122 | ## Reference 123 | 124 | update later 125 | 126 | -------------------------------------------------------------------------------- /data_test/TestCorpus_gold_16.seg.txt: -------------------------------------------------------------------------------- 1 | 共同 创造 美好 的 新 世纪 —— 二○○一年 新年 贺词 2 | （ 二○○○年 十二月 三十一日 ） （ 附 图片 1 张 ） 3 | 女士 们 ， 先生 们 ， 同志 们 ， 朋友 们 ： 4 | 2001年 新年 钟声 即将 敲响 。 人类 社会 前进 的 航船 就要 驶入 21 世纪 的 新 航程 。 中国 人民 进入 了 向 现代化 建设 第三 步 战略 目标 迈进 的 新 征程 。 5 | 在 这个 激动人心 的 时刻 ， 我 很 高兴 通过 中国 国际 广播 电台 、 中央 人民 广播 电台 和 中央 电视台 ， 向 全国 各族 人民 ， 向 香港 特别 行政区 同胞 、 澳门 特别 行政区 同胞 和 台湾 同胞 、 海外 侨胞 ， 向 世界 各国 的 朋友 们 ， 致以 新 世纪 第一 个 新年 的 祝贺 ！ 6 | 过去 的 一 年 ， 是 我国 社会主义 改革 开放 和 现代化 建设 进程 中 具有 标志 意义 的 一 年 。 在 中国 共产党 的 领导 下 ， 全国 各族 人民 团结 奋斗 ， 国民经济 继续 保持 较 快 的 发展 势头 ， 经济 结构 的 战略性 调整 顺利 部署 实施 。 西部 大 开发 取得 良好 开端 。 精神文明 建设 和 民主 法制 建设 进一步 加强 。 我们 在 过去 几 年 取得 成绩 的 基础 上 ， 胜利 完成 了 第九 个 五年计划 。 我国 已 进入 了 全面 建设 小康 社会 ， 加快 社会主义 现代化 建设 的 新 的 发展 阶段 。 7 | 面对 新 世纪 ， 世界 各国 人民 的 共同 愿望 是 ： 继续 发展 人类 以往 创造 的 一切 文明 成果 ， 克服 20 世纪 困扰 着 人类 的 战争 和 贫困 问题 ， 推进 和平 与 发展 的 崇高 事业 ， 创造 一个 美好 的 世界 。 8 | 我们 希望 ， 新 世纪 成为 各国 人民 共享 和平 的 世纪 。 在 20 世纪 里 ， 世界 饱受 各种 战争 和 冲突 的 苦难 。 时至今日 ， 仍 有 不少 国家 和 地区 的 人民 还 在 忍受 战火 的 煎熬 。 中国 人民 真诚 地 祝愿 他们 早日 过 上 和平 安定 的 生活 。 中国 人民 热爱 和平 与 自由 ， 始终 奉行 独立自主 的 和平 外交 政策 ， 永远 站 在 人类 正义 事业 的 一边 。 我们 愿 同 世界 上 一切 爱好 和平 的 国家 和 人民 一道 ， 为 促进 世界 多极化 ， 建立 和平 稳定 、 公正 合理 的 国际 政治 经济 新 秩序 而 努力 奋斗 。 9 | 我们 希望 ， 新 世纪 成为 各国 人民 共同 发展 的 世纪 。 在 20 世纪 里 ， 世界 的 生产力 和 科学技术 取得 了 惊人 的 成就 。 但是 ， 世界 上 仍 有 许多 人民 尚未 摆脱 贫穷 和 饥饿 ， 有的 甚至 连 基本 生存 条件 都 不 具备 ， 时刻 面临 着 死亡 的 威胁 。 经济 全球化 对 生产力 发展 的 新 推动 ， 科学技术 突飞猛进 带来 的 新 成果 ， 应该 造福 于 全人类 ， 特别 是 应该 用 来 促进 发展中国家 的 发展 ， 改善 极度 贫困 人口 的 生活 境遇 ， 使 他们 得以 具备 自我 发展 的 条件 。 中国 人民 将 坚持不懈 地 为此 作出 自己 的 贡献 。 10 | 我们 希望 ， 新 世纪 成为 各种 文明 共同 进步 的 世纪 。 世界 是 丰富多彩 的 。 世界 各国 的 文明 ， 都 是 人类 的 宝贵 财富 ， 应该 相互 尊重 、 相互 学习 。 历史 充分 证明 ， 各国 人民 自主 选择 各自 的 社会制度 和 发展 道路 ， 在 继承 和 发展 本 民族 文明 的 基础 上 吸取 其他 文明 的 精华 ， 按照 自己 的 意志 创造 并 享受 美好 的 生活 ， 是 世界 发展 的 重要 动力 。 只有 加强 各种 文明 之间 的 交流 ， 推动 各种 文明 共同 进步 ， 世界 和平 与 发展 的 崇高 事业 才 能 真正 实现 。 11 | 中国 人民 进入 新 世纪 的 主要 任务 ， 就 是 继续 推进 现代化 建设 ， 完成 祖国 统一 ， 维护 世界 和平 与 促进 共同 发展 。 中国 人民 将 坚持 以 邓小平理论 为 指导 ， 坚定不移 地 推进 改革 开放 和 经济 建设 ， 坚定不移 地 贯彻 “ 和平 统一 、 一国两制 ” 方针 ， 坚定不移 地 奉行 独立自主 的 和平 外交 政策 ， 为 不断 推进 建设 有 中国 特色 社会主义 事业 ， 最终 实现 祖国 的 完全 统一 ， 实现 中华民族 的 伟大 复兴 而 不懈 奋斗 ， 争取 对 人类 作出 新 的 更 大 的 贡献 。 12 | 我 相信 ， 只要 全世界 人民 以及 所有 关心 人类 前途 和 命运 的 政治家 们 共同 努力 ， 携手 前进 ， 我们 居住 的 这个 星球 一定 能够 成为 各国 人民 共享 和平 、 共同 发展 和 共同 进步 的 美好 世界 ！ 13 | 最后 ， 我 从 北京 祝 大家 新年 快乐 ！ 14 | （ 新华社 北京 12月 31日 电 ） 15 | 中共中央 总书记 、 国家 主席 、 中央军委 主席 江 泽民 发表 新年 贺词 。 16 | 2001年 1月 1日 零时 ， 随着 新 世纪 钟声 的 响起 ， 北京 中华 世纪坛 礼花 齐 放 ， 万民 欢腾 。 （ 本报 记者 徐 烨 摄 ） -------------------------------------------------------------------------------- /data_test/TrainingCorpus_16.seg.txt: -------------------------------------------------------------------------------- 1 | 迈向 充满 希望 的 新 世纪 —— 一九九八年 新年 讲话 （ 附 图片 １ 张 ） 2 | 中共中央 总书记 、 国家 主席 江 泽民 3 | （ 一九九七年 十二月 三十一日 ） 4 | １２月 ３１日 ， 中共中央 总书记 、 国家 主席 江 泽民 发表 １９９８年 新年 讲话 《 迈向 充满 希望 的 新 世纪 》 。 （ 新华社 记者 兰 红光 摄 ） 5 | 同胞 们 、 朋友 们 、 女士 们 、 先生 们 ： 6 | 在 １９９８年 来临 之际 ， 我 十分 高兴 地 通过 中央 人民 广播 电台 、 中国 国际 广播 电台 和 中央 电视台 ， 向 全国 各族 人民 ， 向 香港 特别 行政区 同胞 、 澳门 和 台湾 同胞 、 海外 侨胞 ， 向 世界 各国 的 朋友 们 ， 致以 诚挚 的 问候 和 良好 的 祝愿 ！ 7 | １９９７年 ， 是 中国 发展 历史 上 非常 重要 的 很 不 平凡 的 一 年 。 中国 人民 决心 继承 邓 小平 同志 的 遗志 ， 继续 把 建设 有 中国 特色 社会主义 事业 推向 前进 。 中国 政府 顺利 恢复 对 香港 行使 主权 ， 并 按照 “ 一国两制 ” 、 “ 港人治港 ” 、 高度 自治 的 方针 保持 香港 的 繁荣 稳定 。 中国 共产党 成功 地 召开 了 第十五 次 全国 代表大会 ， 高举 邓小平理论 伟大 旗帜 ， 总结 百年 历史 ， 展望 新 的 世纪 ， 制定 了 中国 跨 世纪 发展 的 行动 纲领 。 8 | 在 这 一 年 中 ， 中国 的 改革 开放 和 现代化 建设 继续 向前 迈进 。 国民经济 保持 了 “ 高 增长 、 低 通胀 ” 的 良好 发展 态势 。 农业 生产 再次 获得 好 的 收成 ， 企业 改革 继续 深化 ， 人民 生活 进一步 改善 。 对外 经济 技术 合作 与 交流 不断 扩大 。 民主 法制 建设 、 精神文明 建设 和 其他 各项 事业 都 有 新 的 进展 。 我们 十分 关注 最近 一个 时期 一些 国家 和 地区 发生 的 金融 风波 ， 我们 相信 通过 这些 国家 和 地区 的 努力 以及 有关 的 国际 合作 ， 情况 会 逐步 得到 缓解 。 总的来说 ， 中国 改革 和 发展 的 全局 继续 保持 了 稳定 。 9 | 在 这 一 年 中 ， 中国 的 外交 工作 取得 了 重要 成果 。 通过 高层 互访 ， 中国 与 美国 、 俄罗斯 、 法国 、 日本 等 大国 确定 了 双方 关系 未来 发展 的 目标 和 指导 方针 。 中国 与 周边 国家 和 广大 发展中国家 的 友好 合作 进一步 加强 。 中国 积极 参与 亚太经合 组织 的 活动 ， 参加 了 东盟 — 中 日 韩 和 中国 — 东盟 首脑 非正式 会晤 。 这些 外交 活动 ， 符合 和平 与 发展 的 时代 主题 ， 顺应 世界 走向 多极化 的 趋势 ， 对于 促进 国际 社会 的 友好 合作 和 共同 发展 作出 了 积极 的 贡献 。 10 | １９９８年 ， 中国 人民 将 满怀信心 地 开创 新 的 业绩 。 尽管 我们 在 经济社会 发展 中 还 面临 不少 困难 ， 但 我们 有 邓小平理论 的 指引 ， 有 改革 开放 近 ２０ 年 来 取得 的 伟大 成就 和 积累 的 丰富 经验 ， 还有 其他 的 各种 有利 条件 ， 我们 一定 能够 克服 这些 困难 ， 继续 稳步前进 。 只要 我们 进一步 解放思想 ， 实事求是 ， 抓住 机遇 ， 开拓进取 ， 建设 有 中国 特色 社会主义 的 道路 就 会 越 走 越 宽广 。 11 | 实现 祖国 的 完全 统一 ， 是 海内外 全体 中国 人 的 共同 心愿 。 通过 中 葡 双方 的 合作 和 努力 ， 按照 “ 一国两制 ” 方针 和 澳门 《 基本法 》 ， １９９９年 １２月 澳门 的 回归 一定 能够 顺利 实现 。 12 | 台湾 是 中国 领土 不可分割 的 一 部分 。 完成 祖国 统一 ， 是 大势所趋 ， 民心所向 。 任何 企图 制造 “ 两 个 中国 ” 、 “ 一中一台 ” 、 “ 台湾 独立 ” 的 图谋 ， 都 注定 要 更 失败 。 希望 台湾 当局 以 民族 大义 为重 ， 拿 出 诚意 ， 采取 实际 的 行动 ， 推动 两岸 经济 文化 交流 和 人员 往来 ， 促进 两岸 直接 通邮 、 通航 、 通商 的 早日 实现 ， 并 尽早 回应 我们 发出 的 在 一个 中国 的 原则 下 两岸 进行 谈判 的 郑重 呼吁 。 13 | 环顾 全球 ， 日益 密切 的 世界 经济 联系 ， 日新月异 的 科技 进步 ， 正在 为 各国 经济 的 发展 提供 历史 机遇 。 但是 ， 世界 还 不 安宁 。 南北 之间 的 贫富 差距 继续 扩大 ； 局部 冲突 时有发生 ； 不 公正 不 合理 的 旧 的 国际 政治经济 秩序 还 没有 根本 改变 ； 发展中国家 在 激烈 的 国际 经济 竞争 中 仍 处于 弱势 地位 ； 人类 的 生存 与 发展 还 面临 种种 威胁 和 挑战 。 和平 与 发展 的 前景 是 光明 的 ， ２１ 世纪 将 是 充满 希望 的 世纪 。 但 前进 的 道路 不 会 也 不 可能 一帆风顺 ， 关键 是 世界 各国 人民 要 进一步 团结 起来 ， 共同 推动 早日 建立 公正 合理 的 国际 政治经济 新 秩序 。 14 | 中国 政府 将 继续 坚持 奉行 独立自主 的 和平 外交 政策 ， 在 和平共处 五 项 原则 的 基础 上 努力 发展 同 世界 各国 的 友好 关系 。 中国 愿意 加强 同 联合国 和 其他 国际 组织 的 协调 ， 促进 在 扩大 经贸 科技 交流 、 保护 环境 、 消除 贫困 、 打击 国际 犯罪 等 方面 的 国际 合作 。 中国 永远 是 维护 世界 和平 与 稳定 的 重要 力量 。 中国 人民 愿 与 世界 各国 人民 一道 ， 为 开创 持久 和平 、 共同 发展 的 新 世纪 而 不懈努力 ！ 15 | 在 这 辞旧迎新 的 美好 时刻 ， 我 祝 大家 新年 快乐 ， 家庭 幸福 ！ 16 | 谢谢 ！ （ 新华社 北京 １２月 ３１日 电 ） -------------------------------------------------------------------------------- /data_test/devCorpus_16.seg.txt: -------------------------------------------------------------------------------- 1 | 全国 工商联 主席 经 叔平 表示 ， 希望 台湾 当局 以 全 民族 的 利益 为重 ， 以 实际 行动 回到 一个 中国 的 原则 立场 上 来 ， 尽早 实现 两岸 高层 领导人 的 接触 和 谈判 ， 共同 完成 祖国 统一 大业 。 也 希望 两岸 的 工商界 同仁 为 发展 两岸 关系 ， 推进 海峡 两岸 的 经济 合作 ， 实现 『 三通 』 献计献策 ， 为 祖国 和平 统一 的 千秋 伟业 作出 贡献 。 2 | 民建 中央 主席 成 思危 说 ， 真诚 希望 台湾 当局 顾全大局 ， 以 两岸 经济 、 社会 发展 的 根本 利益 、 共同 要求 和 中华民族 的 统一 与 振兴 为 出发点 ， 拿 出 诚意 ， 采取 实际 行动 ， 打破 两岸 僵局 ， 为 早日 实现 『 三通 』 和 开始 两岸 谈判 创造 条件 。 民建 与 台湾 经济界 人士 素有 联系 ， 我们 愿意 尽可能 地 发挥 这 一 优势 ， 认真 贯彻 江 泽民 主席 的 主张 ， 推动 两岸 经贸 交流 合作 和 两岸 经济界 人士 的 往来 与 交流 ， 为 海峡 两岸 的 繁荣 与 稳定 ， 为 早日 实现 祖国 的 和平 统一 ， 作出 应有 的 贡献 。 3 | 农工党 中央 主席 蒋 正华 认为 ， 多 年 以来 ， 中国 共产党 和 政府 从 中华民族 利益 出发 ， 顺应 民心 ， 坚持 一个 中国 ， 为 推动 两岸 关系 的 良性 发展 作出 了 不懈 的 努力 。 从 邓 小平 同志 提 出 『 和平 统一 、 一国两制 』 方针 到 江 泽民 主席 发表 的 发展 两岸 关系 、 推进 祖国 和平 统一 进程 的 八 项 主张 ， 无不 显示 出 恢宏博大 的 气度 和 推进 统一 的 赤诚 之 心 。 希望 台湾 当局 审时度势 ， 以 民族 大义 为重 ， 做出 有利于 台湾 同胞 、 也 有利于 中华民族 整体 利益 的 正确 选择 。 4 | 民盟 中央 副 主席 吴 修平 说 ， 江 泽民 主席 的 讲话 代表 了 中华民族 的 根本 利益 ， 反映 了 海内外 中国 人 的 共同 心愿 ， 是 原则性 和 灵活性 高度 统一 的 切实可行 的 举措 。 扩大 海峡 两岸 的 交流 与 合作 是 大势所趋 ， 人心所向 。 在 迈向 新 世纪 的 时刻 ， 我们 热切 盼望 海峡 两岸 关系 有 一个 新 的 进展 ， 盼望 两岸 暂时 的 分离 状态 早日 结束 ， 盼望 两岸 同胞 携起手来 ， 共同 迎接 新 世纪 的 到来 。 5 | 民革 中央 副 主席 李 赣骝 认为 ， 当前 两岸 的 根本 分歧 是 坚持 一个 中国 ， 还是 要 搞 『 两 个 中国 』 、 『 一中一台 』 。 我们 希望 台湾 当局 能够 迷途知返 ， 以 两千一百万 台湾 人民 的 福祉 和 民族 大义 为重 ， 对 江 主席 提 出 的 八 项 看法 和 主张 ， 以及 江 主席 不久前 发出 的 郑重 呼吁 ， 作出 积极 的 善意 回应 ， 回到 一个 中国 的 正确 立场 上 来 ， 尽早 举行 两岸 政治 谈判 ， 为 推进 两岸 关系 的 发展 和 祖国 统一 大业 多 做 一些 实事 。 6 | 民进 中央 主席 许 嘉璐 说 ， 三 年 来 ， 江 主席 关于 发展 两岸 关系 的 看法 和 主张 得到 了 海峡 两岸 同胞 、 港澳 同胞 、 海外 侨胞 以及 世界 上 一切 关心 中国 统一 的 人们 的 欢迎 和 响应 ， 对 推动 两岸 关系 的 发展 起 到 了 积极 的 作用 。 按照 江 主席 讲话 的 精神 发展 两岸 关系 ， 就 一定 会 有利于 台湾 经济 和 社会 的 发展 ， 有利于 整个 中华民族 的 全面 振兴 。 7 | 台盟 中央 秘书长 李 敏宽 表示 ， 作为 在 祖国 大陆 的 台湾 同胞 ， 我们 欣慰 地 看到 ， 两岸 经济 、 文化 关系 持续 发展 ， 间接 贸易 逐年 增长 ， 台胞 对 祖国 大陆 投资 从未 间断 ， 两岸 科技 、 文化 、 教育 、 体育 等 各个 领域 的 交流 蓬勃 发展 ， 两岸 直接 通邮 、 通航 取得 局部 进展 。 我们 认为 ， 一个 中国 的 原则 是 两岸 关系 稳定 发展 的 基础 。 在 一个 中国 的 原则 下 ， 通过 政治 谈判 解决 双方 的 政治 分歧 ， 这 是 改善 和 发展 两岸 关系 的 必由之路 。 8 | 致公党 中央 主席 罗 豪才 说 ， 江 泽民 主席 的 重要 讲话 ， 精辟 地 论述 了 邓 小平 同志 『 和平 统一 、 一国两制 』 思想 的 精髓 ， 提 出 了 现阶段 发展 两岸 关系 、 推进 祖国 和平 统一 进程 的 八 项 主张 。 三 年 来 的 实践 充分 证明 ， 江 主席 提 出 的 八 项 主张 ， 反映 了 海峡 两岸 同胞 的 根本 利益 ， 对 推动 两岸 关系 发展 、 促进 祖国 统一 大业 早日 实现 ， 具有 重大 的 现实 意义 和 深远 的 历史 意义 。 9 | 九三学社 中央 副 主席 赵 伟之 说 ， 在 一个 中国 的 原则 基础 上 发展 两岸 关系 ， 推进 祖国 和平 统一 的 进程 ， 目前 已 是 大势所趋 。 我们 敦促 台湾 当局 顺应 历史 潮流 和 两岸 民意 ， 尽快 改变 制造 『 两 个 中国 』 或 『 一中一台 』 的 错误 做法 ， 回到 一个 中国 的 原则 上 来 ， 认真 正面 回应 江 泽民 主席 的 郑重 呼吁 和 八 项 主张 ， 为 尽早 举行 两岸 政治 谈判 、 发展 两岸 关系 做 些 实实在在 的 事情 。 10 | 民盟 中央 主席 丁 石孙 、 台盟 中央 主席 张 克辉 也 出席 了 今天 的 座谈会 。 11 | 长江 口 深水 航道 治理 一 期 工程 开工 12 | 李 鹏 邹 家华 题词 吴 邦国 出席 开工 典礼 并 讲话 13 | 据 新华社 上海 １月 ２７日 电 （ 记者 罗 康雄 、 孙 杰 ） 长江 口 深水 航道 治理 一 期 工程 今天 在 上海 浦东 新区 外高桥 沿 江 大堤 宣告 开工 。 这 一 大型 水运 工程 的 启动 ， 标志 着 长江 口 “ 瓶颈 ” 将 被 打通 。 国务院 总理 李 鹏 为 此 题词 ： “ 治理 长江 口 深水 航道 ， 促进 上海 国际 经济 中心 建设 ， 带动 长江 三角洲 新 飞跃 。 ” 14 | 国务院 副 总理 吴 邦国 出席 了 今天 的 开工 典礼 并 发表 讲话 。 国务院 副 总理 邹 家华 为 这 一 工程 开工 题词 ： “ 尊重 科学 ， 改造 自然 ， 推动 航运 ， 促进 发展 。 ” 15 | 吴 邦国 首先 代表 国务院 对 参加 长江 口 深水 航道 治理 的 工程建设者 们 表示 亲切 的 慰问 。 他 说 ， 作为 我国 又 一 项 跨 世纪 的 宏伟 工程 ， 长江 口 深水 航道 治理 工程 的 正式 开工 标志 着 我国 航道 整治 水平 的 提高 ， 标志 着 上海 国际 航运 中心 的 建设 向前 迈出 了 一 大 步 。 16 | 吴 邦国 说 ， 在 邓 小平 同志 的 倡导 下 ， 党中央 、 国务院 作出 了 开发 开放 上海 浦东 的 重大 战略 决策 。 党 的 十四大 又 进一步 明确 ， 要 “ 以 上海 浦东 开发 开放 为 龙头 ， 进一步 开放 长江 沿岸 城市 ， 尽快 把 上海 建成 国际 经济 、 金融 、 贸易 中心 ， 带动 长江 三角洲 和 整个 长江 流域 地区 经济 新 飞跃 ” 。 为 实现 上海 “ 一个 龙头 、 三 个 中心 ” 的 战略 目标 ， 党中央 、 国务院 提 出 把 上海 建设 成为 国际 航运 中心 的 要求 ， 而 开辟 长江 口 深水 航道 ， 是 建设 上海 国际 航运 中心 的 基础 工程 和 前提 条件 ， 社会效益 和 经济效益 十分 显著 。 -------------------------------------------------------------------------------- /eval.py: -------------------------------------------------------------------------------- 1 | class Eval: 2 | def __init__(self): 3 | self.predict_num = 0 4 | self.correct_num = 0 5 | self.gold_num = 0 6 | 7 | self.precision = 0 8 | self.recall = 0 9 | self.fscore = 0 10 | 11 | def clear(self): 12 | self.predict_num = 0 13 | self.correct_num = 0 14 | self.gold_num = 0 15 | 16 | self.precision = 0 17 | self.recall = 0 18 | self.fscore = 0 19 | 20 | def getFscore(self): 21 | if self.predict_num == 0: 22 | self.precision = 0 23 | else: 24 | self.precision = (self.correct_num / self.predict_num) * 100 25 | 26 | if self.gold_num == 0: 27 | self.recall = 0 28 | else: 29 | self.recall = (self.correct_num / self.gold_num) * 100 30 | 31 | if self.precision + self.recall == 0: 32 | self.fscore = 0 33 | else: 34 | self.fscore = 2 * (self.precision * self.recall) / (self.precision + self.recall) 35 | 36 | return self.precision, self.recall, self.fscore 37 | 38 | def acc(self): 39 | return self.correct_num / self.gold_num 40 | -------------------------------------------------------------------------------- /hyperparams.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import random 3 | torch.manual_seed(121) 4 | random.seed(121) 5 | # random seed 6 | seed_num = 233 7 | 8 | 9 | class Hyperparams(): 10 | def __init__(self): 11 | 12 | # data path 13 | self.train_path = "./data_test/TrainingCorpus_16.seg.txt" 14 | self.dev_path = "./data_test/devCorpus_16.seg.txt" 15 | self.test_path = "./data_test/TestCorpus_gold_16.seg.txt" 16 | 17 | # self.train_path = "./data/TrainingCorpus.seg.txt" 18 | # self.dev_path = "./data/devCorpus.seg.txt" 19 | # self.test_path = "./data/TestCorpus_gold.seg.txt" 20 | 21 | self.learning_rate = 0.001 22 | # self.learning_rate_decay = 0.9 # value is 1 means not change lr 23 | self.learning_rate_decay = 1 # value is 1 means not change lr 24 | self.epochs = 200 25 | self.train_batch_size = 16 26 | self.dev_batch_size = 16 27 | self.test_batch_size = 16 28 | self.log_interval = 1 29 | self.dev_interval = 4000000 30 | self.test_interval = 4000000 31 | self.save_dir = "snapshot" 32 | self.shuffle = False 33 | self.epochs_shuffle = True 34 | self.dropout = 0.25 35 | self.dropout_embed = 0.25 36 | self.dropout_lstm = 0.5 37 | self.max_norm = None 38 | self.clip_max_norm = 10 39 | self.static = False 40 | # model 41 | self.Wordlstm = True 42 | self.Encoder_LSTM = False 43 | self.Encoder_LSTMCell = True 44 | # select optim algorhtim to train 45 | self.Adam = True 46 | self.SGD = False 47 | self.Adadelta = False 48 | self.optim_momentum_value = 0.9 49 | # min freq to include during built the vocab, default is 1 50 | self.min_freq = 1 51 | self.word_min_freq = 1 52 | self.char_min_freq = 2 53 | self.bichar_min_freq = 2 54 | # word_Embedding 55 | self.word_Embedding = True 56 | self.word_Embedding_Path = "./word2vec/glove.sentiment.conj.pretrained.txt" 57 | self.fix_Embedding = False 58 | self.embed_dim = 300 59 | self.embed_char_dim = 200 60 | self.embed_bichar_dim = 200 61 | # word_Embedding_Path = "./word2vec/glove.840B.300d.handled.Twitter.txt" 62 | self.char_Embedding = False 63 | self.char_Embedding_path = "./word_embedding/char.vec" 64 | self.bichar_Embedding = False 65 | # self.bichar_Embedding_Path = "./word_embedding/char.vec" 66 | self.bichar_Embedding_Path = "./word_embedding/bichar-small.vec" 67 | # self.bichar_Embedding_Path = "./word_embedding/convert_bichar.txt" 68 | # self.pos_num = None 69 | self.pos_dim = 100 70 | 71 | self.rnn_hidden_dim = 200 72 | self.hidden_size = 200 73 | self.rnn_num_layers = 1 74 | self.gpu_device = 0 75 | self.use_cuda = False 76 | self.snapshot = None 77 | self.num_threads = 1 78 | # whether to init w 79 | self.init_weight = True 80 | self.init_weight_value = 6.0 81 | # L2 weight_decay 82 | self.weight_decay = 1e-8 # default value is zero in Adam SGD 83 | # self.weight_decay = 0 # default value is zero in Adam SGD 84 | # whether to delete the model after test acc so that to save space 85 | self.rm_model = True 86 | 87 | 88 | 89 | -------------------------------------------------------------------------------- /loaddata/Alphabet.py: -------------------------------------------------------------------------------- 1 | # coding=utf-8 2 | import torch 3 | import random 4 | import collections 5 | from loaddata.common import sep, app, nullkey, paddingkey, unkkey 6 | import hyperparams as hy 7 | torch.manual_seed(hy.seed_num) 8 | random.seed(hy.seed_num) 9 | 10 | 11 | """ 12 | Create alphabet by train/dev/test data 13 | """ 14 | 15 | 16 | class Create_Alphabet(): 17 | def __init__(self, min_freq=1, word_min_freq=1, char_min_freq=1, bichar_min_freq=1,): 18 | 19 | self.min_freq = min_freq 20 | self.word_min_freq = word_min_freq 21 | self.char_min_freq = char_min_freq 22 | self.bichar_min_freq = bichar_min_freq 23 | 24 | self.word_state = collections.OrderedDict() 25 | self.char_state = collections.OrderedDict() 26 | self.bichar_state = collections.OrderedDict() 27 | self.pos_state = collections.OrderedDict() 28 | 29 | self.word_alphabet = Alphabet(min_freq=word_min_freq) 30 | # self.char_alphabet = Alphabet(min_freq=min_freq) 31 | # self.bichar_alphabet = Alphabet(min_freq=min_freq) 32 | self.char_alphabet = Alphabet(min_freq=char_min_freq) 33 | self.bichar_alphabet = Alphabet(min_freq=bichar_min_freq) 34 | # pos min_freq = 1, not cut 35 | self.pos_alphabet = Alphabet(min_freq=1) 36 | self.label_alphabet = Alphabet(min_freq=min_freq) 37 | 38 | # unkid 39 | # self.word_UnkkID = None 40 | # self.char_UnkID = None 41 | # self.bichar_UnkID = None 42 | # self.pos_UnkID = None 43 | self.word_UnkkID = 0 44 | self.char_UnkID = 0 45 | self.bichar_UnkID = 0 46 | self.pos_UnkID = 0 47 | 48 | # paddingid 49 | # self.word_PaddingID = None 50 | # self.char_PaddingID = None 51 | # self.bichar_PaddingID = None 52 | # self.pos_PaddingID = None 53 | self.word_PaddingID = 0 54 | self.char_PaddingID = 0 55 | self.bichar_PaddingID = 0 56 | self.pos_PaddingID = 0 57 | 58 | # self.appID = None 59 | # self.sepID = None 60 | self.appID = 0 61 | self.sepID = 0 62 | 63 | def createAlphabet(self, train_data=None, dev_data=None, test_data=None, debug_index=-1): 64 | print("create Alphabet start...... ! ") 65 | # handle the data whether to fine_tune 66 | assert train_data is not None 67 | datasets = [] 68 | datasets.extend(train_data) 69 | print("the length of train data {}".format(len(datasets))) 70 | if dev_data is not None: 71 | print("the length of dev data {}".format(len(dev_data))) 72 | datasets.extend(dev_data) 73 | if test_data is not None: 74 | print("the length of test data {}".format(len(test_data))) 75 | datasets.extend(test_data) 76 | print("the length of data that create Alphabet {}".format(len(datasets))) 77 | # create the word Alphabet 78 | for index, data in enumerate(datasets): 79 | # word 80 | for word in data.words: 81 | if word not in self.word_state: 82 | self.word_state[word] = 1 83 | else: 84 | self.word_state[word] += 1 85 | # char 86 | for char in data.chars: 87 | if char not in self.char_state: 88 | self.char_state[char] = 1 89 | else: 90 | self.char_state[char] += 1 91 | # bichar_left 92 | for bichar in data.bichars_left: 93 | if bichar not in self.bichar_state: 94 | self.bichar_state[bichar] = 1 95 | else: 96 | self.bichar_state[bichar] += 1 97 | bichar = data.bichars_right[-1] 98 | if bichar not in self.bichar_state: 99 | self.bichar_state[bichar] = 1 100 | else: 101 | self.bichar_state[bichar] += 1 102 | # label pos 103 | for pos in data.pos: 104 | if pos not in self.pos_state: 105 | self.pos_state[pos] = 1 106 | else: 107 | self.pos_state[pos] += 1 108 | # copy with the gold "SEP#PN" 109 | for gold in data.gold: 110 | self.label_alphabet.loadWord2idAndId2Word(gold) 111 | 112 | if index == debug_index: 113 | # only some sentence for debug 114 | print(self.word_state, "************************") 115 | print(self.char_state, "*************************") 116 | print(self.bichar_state, "*************************") 117 | print(self.pos_state, "*************************") 118 | print(self.label_alphabet.words2id) 119 | break 120 | 121 | # copy with the seq/app/unkkey/nullkey/paddingkey 122 | self.word_state[unkkey] = self.word_min_freq 123 | self.word_state[paddingkey] = self.word_min_freq 124 | self.char_state[unkkey] = self.char_min_freq 125 | self.char_state[paddingkey] = self.char_min_freq 126 | self.bichar_state[unkkey] = self.bichar_min_freq 127 | self.bichar_state[paddingkey] = self.bichar_min_freq 128 | self.pos_state[unkkey] = 1 129 | self.pos_state[paddingkey] = 1 130 | 131 | 132 | 133 | # create the id2words and words2id 134 | self.word_alphabet.initialWord2idAndId2Word(self.word_state) 135 | self.char_alphabet.initialWord2idAndId2Word(self.char_state) 136 | self.bichar_alphabet.initialWord2idAndId2Word(self.bichar_state) 137 | self.pos_alphabet.initialWord2idAndId2Word(self.pos_state) 138 | 139 | # copy with the unkID 140 | self.word_UnkkID = self.word_alphabet.loadWord2idAndId2Word(unkkey) 141 | self.char_UnkID = self.char_alphabet.loadWord2idAndId2Word(unkkey) 142 | self.bichar_UnkID = self.bichar_alphabet.loadWord2idAndId2Word(unkkey) 143 | self.pos_UnkID = self.pos_alphabet.loadWord2idAndId2Word(unkkey) 144 | 145 | # copy with the PaddingID 146 | self.word_PaddingID = self.word_alphabet.loadWord2idAndId2Word(paddingkey) 147 | self.char_PaddingID = self.char_alphabet.loadWord2idAndId2Word(paddingkey) 148 | self.bichar_PaddingID = self.bichar_alphabet.loadWord2idAndId2Word(paddingkey) 149 | self.pos_PaddingID = self.pos_alphabet.loadWord2idAndId2Word(paddingkey) 150 | 151 | self.word_alphabet.set_fixed_flag(True) 152 | self.char_alphabet.set_fixed_flag(True) 153 | self.bichar_alphabet.set_fixed_flag(True) 154 | self.pos_alphabet.set_fixed_flag(True) 155 | self.label_alphabet.set_fixed_flag(True) 156 | 157 | # copy the app seq ID 158 | self.appID = self.label_alphabet.loadWord2idAndId2Word(app) 159 | self.sepID = self.label_alphabet.loadWord2idAndId2Word(sep) 160 | 161 | 162 | class Alphabet(): 163 | def __init__(self, min_freq=1): 164 | self.id2words = [] 165 | self.words2id = collections.OrderedDict() 166 | self.word2id_id = 0 167 | self.m_size = 0 168 | self.min_freq = min_freq 169 | self.max_cap = 1e8 170 | self.m_b_fixed = False 171 | 172 | def initialWord2idAndId2Word(self, data): 173 | for key in data: 174 | if data[key] >= self.min_freq: 175 | # Alphabet.loadWord2idAndId2Word(self, key) 176 | self.loadWord2idAndId2Word(key) 177 | self.set_fixed_flag(True) 178 | 179 | # def loadWord2idAndId2Word(self, string): 180 | # if string in self.words2id: 181 | # return self.words2id[string] 182 | # new_id = self.word2id_id 183 | # self.id2words.append(string) 184 | # self.words2id[string] = new_id 185 | # self.word2id_id += 1 186 | # self.m_size = self.word2id_id 187 | 188 | def set_fixed_flag(self, bfixed): 189 | self.m_b_fixed = bfixed 190 | if (not self.m_b_fixed) and (self.m_size >= self.max_cap): 191 | self.m_b_fixed = True 192 | 193 | def loadWord2idAndId2Word(self, string): 194 | if string in self.words2id: 195 | return self.words2id[string] 196 | else: 197 | if not self.m_b_fixed: 198 | newid = self.m_size 199 | self.id2words.append(string) 200 | self.words2id[string] = newid 201 | self.m_size += 1 202 | if self.m_size >= self.max_cap: 203 | self.m_b_fixed = True 204 | return newid 205 | else: 206 | return -1 207 | 208 | # def loadWord2idAndId2Word(self, string): 209 | # if string in self.words2id: 210 | # return self.words2id[string] 211 | # else: 212 | # if not self.m_b_fixed: 213 | # new_id = self.word2id_id 214 | # self.id2words.append(string) 215 | # self.words2id[string] = new_id 216 | # self.word2id_id += 1 217 | # self.m_size = self.word2id_id 218 | # if self.m_size >= self.max_cap: 219 | # self.m_b_fixed = True 220 | # return new_id 221 | # else: 222 | # return -1 223 | 224 | def from_id(self, qid, defineStr = ''): 225 | if int(qid) < 0 or self.m_size <= qid: 226 | return defineStr 227 | else: 228 | return self.id2words[qid] 229 | 230 | -------------------------------------------------------------------------------- /loaddata/Batch_Iterator.py: -------------------------------------------------------------------------------- 1 | # coding=utf-8 2 | import torch 3 | from torch.autograd import Variable 4 | import random 5 | from loaddata.common import sep, app, nullkey, paddingkey, unkkey 6 | from loaddata.Instance import instance, Batch_Features 7 | import hyperparams as hy 8 | torch.manual_seed(hy.seed_num) 9 | random.seed(hy.seed_num) 10 | 11 | 12 | class Iterators(): 13 | # def __init__(self, batch_size=1, data=None, operator=None): 14 | def __init__(self): 15 | self.args = None 16 | self.batch_size = None 17 | self.data = None 18 | self.operator = None 19 | self.operator_static = None 20 | self.iterator = [] 21 | self.batch = [] 22 | self.features = [] 23 | self.data_iter = [] 24 | 25 | def createIterator(self, batch_size=None, data=None, operator=None, operator_static=None, args=None): 26 | assert isinstance(data, list), "ERROR: data must be in list [train_data,dev_data]" 27 | assert isinstance(batch_size, list), "ERROR: batch_size must be in list [16,1,1]" 28 | self.args = args 29 | self.batch_size = batch_size 30 | self.data = data 31 | self.operator = operator 32 | self.operator_static = operator_static 33 | for id_data in range(len(data)): 34 | print("***************** create {} iterator **************".format(id_data + 1)) 35 | self.convert_word2id(self.data[id_data], self.operator, self.operator_static) 36 | self.features = self.create_onedata_Iterator(insts=self.data[id_data], batch_size=self.batch_size[id_data], 37 | operator=self.operator, 38 | operator_static=self.operator_static) 39 | self.data_iter.append(self.features) 40 | self.features = [] 41 | return self.data_iter[0], self.data_iter[1], self.data_iter[2] 42 | # return self.data_iter[0] 43 | 44 | def convert_word2id(self, insts, operator, operator_static): 45 | # print(len(insts)) 46 | # for index_inst, inst in enumerate(insts): 47 | for inst in insts: 48 | # copy with the word and pos 49 | for index in range(inst.words_size): 50 | word = inst.words[index] 51 | wordID = operator.word_alphabet.loadWord2idAndId2Word(word) 52 | # if wordID is None: 53 | if wordID == -1: 54 | wordID = operator.word_UnkkID 55 | # wordID = operator 56 | inst.words_index.append(wordID) 57 | 58 | pos = inst.pos[index] 59 | posID = operator.pos_alphabet.loadWord2idAndId2Word(pos) 60 | # if posID is None: 61 | if posID == -1: 62 | posID = operator.pos_UnkID 63 | inst.pos_index.append(posID) 64 | # print(inst.words_index) 65 | # print(inst.pos_index) 66 | # copy with the char 67 | for index in range(inst.chars_size): 68 | char = inst.chars[index] 69 | charID = operator.char_alphabet.loadWord2idAndId2Word(char) 70 | static_charID = operator_static.char_alphabet.loadWord2idAndId2Word(char) 71 | # if charID is None: 72 | if charID == -1: 73 | charID = operator.char_UnkID 74 | if static_charID == -1: 75 | static_charID = operator_static.char_UnkID 76 | inst.chars_index.append(charID) 77 | inst.static_chars_index.append(static_charID) 78 | # print(inst.chars_index) 79 | # copy with the bichar_left 80 | for index in range(inst.bichars_size): 81 | bichar_left = inst.bichars_left[index] 82 | bichar_left_ID = operator.bichar_alphabet.loadWord2idAndId2Word(bichar_left) 83 | static_bichar_left_ID = operator_static.bichar_alphabet.loadWord2idAndId2Word(bichar_left) 84 | # if bichar_left_ID is None: 85 | if bichar_left_ID == -1: 86 | bichar_left_ID = operator.bichar_UnkID 87 | if static_bichar_left_ID == -1: 88 | static_bichar_left_ID = operator_static.bichar_UnkID 89 | inst.bichars_left_index.append(bichar_left_ID) 90 | inst.static_bichars_left_index.append(static_bichar_left_ID) 91 | # print(inst.bichars_left_index) 92 | 93 | # copy with the bichar_right 94 | for index in range(inst.bichars_size): 95 | bichar_right = inst.bichars_right[index] 96 | bichar_right_ID = operator.bichar_alphabet.loadWord2idAndId2Word(bichar_right) 97 | static_bichar_right_ID = operator_static.bichar_alphabet.loadWord2idAndId2Word(bichar_right) 98 | # if bichar_right_ID == -1: 99 | # if bichar_right_ID is None: 100 | if bichar_right_ID == -1: 101 | bichar_right_ID = operator.bichar_UnkID 102 | if static_bichar_right_ID == -1: 103 | static_bichar_right_ID = operator_static.bichar_UnkID 104 | inst.bichars_right_index.append(bichar_right_ID) 105 | inst.static_bichars_right_index.append(static_bichar_right_ID) 106 | # print(inst.bichars_right_index) 107 | 108 | # copy with the gold 109 | for index in range(inst.gold_size): 110 | gold = inst.gold[index] 111 | goldID = operator.label_alphabet.loadWord2idAndId2Word(gold) 112 | # print("gold ID ", goldID) 113 | inst.gold_index.append(goldID) 114 | 115 | def create_onedata_Iterator(self, insts, batch_size, operator, operator_static): 116 | batch = [] 117 | count_inst = 0 118 | for index, inst in enumerate(insts): 119 | batch.append(inst) 120 | count_inst += 1 121 | # print(batch) 122 | if len(batch) == batch_size or count_inst == len(insts): 123 | # print("aaaa", len(batch)) 124 | one_batch = self.create_one_batch(insts=batch, batch_size=batch_size, operator=operator, 125 | operator_static=operator_static) 126 | self.features.append(one_batch) 127 | batch = [] 128 | print("The all data has created iterator.") 129 | return self.features 130 | 131 | def create_one_batch(self, insts, batch_size, operator, operator_static): 132 | # print("create one batch......") 133 | batch_length = len(insts) 134 | # copy with the max length for padding 135 | max_word_size = -1 136 | max_char_size = -1 137 | max_bichar_size = -1 138 | max_gold_size = -1 139 | max_pos_size = -1 140 | for inst in insts: 141 | word_size = inst.words_size 142 | if word_size > max_word_size: 143 | max_word_size = word_size 144 | char_size = inst.chars_size 145 | if char_size > max_char_size: 146 | max_char_size = char_size 147 | bichar_size = inst.bichars_size 148 | if bichar_size > max_bichar_size: 149 | max_bichar_size = bichar_size 150 | gold_size = inst.gold_size 151 | if gold_size > max_gold_size: 152 | max_gold_size = gold_size 153 | 154 | # create with the Tensor/Variable 155 | # word features 156 | batch_word_features = Variable(torch.LongTensor(batch_length, max_word_size)) 157 | batch_pos_features = Variable(torch.LongTensor(batch_length, max_word_size)) 158 | 159 | batch_char_features = Variable(torch.LongTensor(batch_length, max_char_size)) 160 | batch_bichar_left_features = Variable(torch.LongTensor(batch_length, max_bichar_size)) 161 | batch_bichar_right_features = Variable(torch.LongTensor(batch_length, max_bichar_size)) 162 | 163 | batch_static_char_features = Variable(torch.LongTensor(batch_length, max_char_size)) 164 | batch_static_bichar_left_features = Variable(torch.LongTensor(batch_length, max_bichar_size)) 165 | batch_static_bichar_right_features = Variable(torch.LongTensor(batch_length, max_bichar_size)) 166 | 167 | batch_gold_features = Variable(torch.LongTensor(max_gold_size * batch_length)) 168 | 169 | # print(batch_gold_features) 170 | 171 | for id_inst in range(batch_length): 172 | inst = insts[id_inst] 173 | # print(inst.words_index) 174 | # copy with the word features 175 | for id_word_index in range(max_word_size): 176 | if id_word_index < inst.words_size: 177 | batch_word_features.data[id_inst][id_word_index] = inst.words_index[id_word_index] 178 | else: 179 | # print(operator.word_PaddingID) 180 | batch_word_features.data[id_inst][id_word_index] = operator.word_PaddingID 181 | 182 | # copy with the pos features 183 | for id_pos_index in range(max_word_size): 184 | if id_pos_index < inst.words_size: 185 | batch_pos_features.data[id_inst][id_pos_index] = inst.pos_index[id_pos_index] 186 | else: 187 | # print("aaa", operator.pos_PaddingID) 188 | batch_pos_features.data[id_inst][id_pos_index] = operator.pos_PaddingID 189 | 190 | # copy with the char features 191 | for id_char_index in range(max_char_size): 192 | if id_char_index < inst.chars_size: 193 | batch_char_features.data[id_inst][id_char_index] = inst.chars_index[id_char_index] 194 | batch_static_char_features.data[id_inst][id_char_index] = inst.static_chars_index[id_char_index] 195 | else: 196 | # print("aaa", operator.char_PaddingID) 197 | batch_char_features.data[id_inst][id_char_index] = operator.char_PaddingID 198 | batch_static_char_features.data[id_inst][id_char_index] = operator_static.char_PaddingID 199 | 200 | # copy with the bichar_left features 201 | for id_bichar_left_index in range(max_bichar_size): 202 | if id_bichar_left_index < inst.bichars_size: 203 | batch_bichar_left_features.data[id_inst][id_bichar_left_index] = inst.bichars_left_index[id_bichar_left_index] 204 | batch_static_bichar_left_features.data[id_inst][id_bichar_left_index] = int(inst.static_bichars_left_index[id_bichar_left_index]) 205 | else: 206 | # print("aaa", operator.bichar_PaddingID) 207 | batch_bichar_left_features.data[id_inst][id_bichar_left_index] = operator.bichar_PaddingID 208 | batch_static_bichar_left_features.data[id_inst][id_bichar_left_index] = int(operator_static.bichar_PaddingID) 209 | 210 | # copy with the bichar_right features 211 | for id_bichar_right_index in range(max_bichar_size): 212 | if id_bichar_right_index < inst.bichars_size: 213 | # batch_bichar_right_features.data[id_inst][id_bichar_right_index] = inst.bichars_left_index[id_bichar_right_index] 214 | batch_bichar_right_features.data[id_inst][id_bichar_right_index] = inst.bichars_right_index[id_bichar_right_index] 215 | batch_static_bichar_right_features.data[id_inst][id_bichar_right_index] = inst.static_bichars_right_index[id_bichar_right_index] 216 | else: 217 | batch_bichar_right_features.data[id_inst][id_bichar_right_index] = operator.bichar_PaddingID 218 | batch_static_bichar_right_features.data[id_inst][id_bichar_right_index] = operator_static.bichar_PaddingID 219 | 220 | # copy with the gold features 221 | for id_gold_index in range(max_gold_size): 222 | if id_gold_index < inst.gold_size: 223 | # print("wwwwww", inst.gold_index[id_gold_index]) 224 | batch_gold_features.data[id_gold_index + id_inst * max_gold_size] = inst.gold_index[id_gold_index] 225 | else: 226 | batch_gold_features.data[id_gold_index + id_inst * max_gold_size] = 0 227 | 228 | # batch 229 | features = Batch_Features() 230 | features.batch_length = batch_length 231 | features.inst = insts 232 | features.word_features = batch_word_features 233 | features.pos_features = batch_pos_features 234 | features.char_features = batch_char_features 235 | features.static_char_features = batch_static_char_features 236 | features.bichar_left_features = batch_bichar_left_features 237 | features.static_bichar_left_features = batch_static_bichar_left_features 238 | features.bichar_right_features = batch_bichar_right_features 239 | features.static_bichar_right_features = batch_static_bichar_right_features 240 | features.gold_features = batch_gold_features 241 | if self.args.use_cuda is True: 242 | features.cuda(features) 243 | return features 244 | 245 | def padding(self, batch_length, insts, operator=None, batch_features=None, max_size=-1): 246 | print("padding") 247 | for id_inst in range(batch_length): 248 | inst = insts[id_inst] 249 | for id_word_index in range(max_size): 250 | if id_word_index < inst.words_size: 251 | print("Failed to write a function for all") 252 | 253 | return "" 254 | 255 | 256 | 257 | 258 | 259 | 260 | 261 | 262 | 263 | 264 | 265 | -------------------------------------------------------------------------------- /loaddata/Dataloader.py: -------------------------------------------------------------------------------- 1 | # coding=utf-8 2 | 3 | import os 4 | import re 5 | import torch 6 | import shutil 7 | import random 8 | import unicodedata 9 | from loaddata.Alphabet import Create_Alphabet 10 | from loaddata.Instance import instance 11 | from loaddata.common import sep, app, paddingkey, unkkey, nullkey, label 12 | # fix the random seed 13 | import hyperparams as hy 14 | torch.manual_seed(hy.seed_num) 15 | random.seed(hy.seed_num) 16 | 17 | 18 | class load_data(): 19 | 20 | def __init__(self, path=[], shuffle=False): 21 | print("load data for train/dev/test") 22 | self.debug_index = -1 23 | self.path = path 24 | self.date_list = [] 25 | 26 | def clean_str(self, string): 27 | """ 28 | Tokenization/string cleaning for all datasets except for SST. 29 | Original taken from https://github.com/yoonkim/CNN_sentence/blob/master/process_data.py 30 | """ 31 | string = re.sub(r"[^A-Za-z0-9(),!?\'\`]", " ", string) 32 | string = re.sub(r"\'s", " \'s", string) 33 | string = re.sub(r"\'ve", " \'ve", string) 34 | string = re.sub(r"n\'t", " n\'t", string) 35 | string = re.sub(r"\'re", " \'re", string) 36 | string = re.sub(r"\'d", " \'d", string) 37 | string = re.sub(r"\'ll", " \'ll", string) 38 | string = re.sub(r",", " , ", string) 39 | string = re.sub(r"!", " ! ", string) 40 | string = re.sub(r"\(", " \( ", string) 41 | string = re.sub(r"\)", " \) ", string) 42 | string = re.sub(r"\?", " \? ", string) 43 | string = re.sub(r"\s{2,}", " ", string) 44 | return string.strip() 45 | 46 | def load_data(self, path=None, shuffle=False): 47 | assert isinstance(path, list), "path must be in list" 48 | for id_data in range(len(path)): 49 | print(path[id_data]) 50 | # sort the data with sentence length 51 | self.sort_data(path=path[id_data]) 52 | # insts = None 53 | # insts = self.load_one_date(path=path[id_data], shuffle=shuffle) 54 | insts = self.load_one_date(path="./temp_data.txt", shuffle=False) 55 | self.date_list.append(insts) 56 | return self.date_list[0], self.date_list[1], self.date_list[2] 57 | 58 | def sort_data(self, path=None): 59 | with open(path, encoding="utf-8") as f: 60 | lines = f.readlines() 61 | lines.sort(key=lambda x: len(x)) 62 | if os.path.exists("./temp_data.txt"): 63 | os.remove("./temp_data.txt") 64 | 65 | file = open("./temp_data.txt", mode="w", encoding="UTF-8") 66 | file.writelines(lines) 67 | # for line in lines: 68 | # file.write(line) 69 | 70 | def load_one_date(self, path=None, shuffle=False): 71 | print("loading {} data......".format(path)) 72 | assert path is not None 73 | insts = [] 74 | with open(path, encoding="UTF-8") as f: 75 | lines = f.readlines() 76 | for index, line in enumerate(lines): 77 | # copy with "/n" 78 | if line is None: 79 | continue 80 | line = unicodedata.normalize('NFKC', line.strip()) 81 | # init instance 82 | inst = instance() 83 | line = line.split(" ") 84 | count = 0 85 | for word in line: 86 | # segment the word and pos in line 87 | # segment with tab space 88 | # word, _, _ = word_pos.partition(" ") 89 | word_length = len(word) 90 | inst.words.append(word) 91 | inst.gold_seg.append("[" + str(count) + "," + str(count + word_length) + "]") 92 | inst.gold_pos.append("[" + str(count) + "," + str(count + word_length) + "]" + label) 93 | count += word_length 94 | for i in range(word_length): 95 | char = word[i] 96 | # print(char) 97 | inst.chars.append(char) 98 | if i == 0: 99 | inst.gold.append(sep + "#" + label) 100 | inst.pos.append(label) 101 | else: 102 | inst.gold.append(app) 103 | char_number = len(inst.chars) 104 | for i in range(char_number): 105 | # copy with the left bichars 106 | if i is 0: 107 | inst.bichars_left.append(nullkey + inst.chars[i]) 108 | else: 109 | inst.bichars_left.append(inst.chars[i - 1] + inst.chars[i]) 110 | # copy with the right bichars 111 | if i == char_number - 1: 112 | inst.bichars_right.append(inst.chars[i] + nullkey) 113 | else: 114 | inst.bichars_right.append(inst.chars[i] + inst.chars[i + 1]) 115 | # char/word size 116 | inst.chars_size = len(inst.chars) 117 | inst.words_size = len(inst.words) 118 | inst.bichars_size = len(inst.bichars_left) 119 | inst.gold_size = len(inst.gold) 120 | # add one inst that represent one sentence into the list 121 | insts.append(inst) 122 | if index == self.debug_index: 123 | break 124 | if shuffle is True: 125 | print("shuffle tha data......") 126 | random.shuffle(insts) 127 | # return all sentence in data 128 | # print(insts[-1].words) 129 | return insts 130 | 131 | 132 | if __name__ == "__main__": 133 | print("Test dataloader........") 134 | loaddata = load_data() 135 | # train_data, dev_data, test_data = loaddata.load_data(path=("../pos_test_data/train.ctb60.pos-1.hwc", "../pos_test_data/dev.ctb60.pos.hwc", 136 | # "../pos_test_data/test.ctb60.pos.hwc"), shuffle=True) 137 | train_data, dev_data, test_data = loaddata.load_data(path=["../pos_test_data/train.ctb60.pos-1.hwc", "../pos_test_data/train.ctb60.pos-1.hwc" 138 | , "../pos_test_data/train.ctb60.pos-1.hwc"], shuffle=True) 139 | # print("\n\n\n\n") 140 | # print(train_data) 141 | # print("\n\n\n\n") 142 | # print(dev_data) 143 | # print("\n\n\n\n") 144 | # print(test_data) 145 | # create_alphabet = Create_Alphabet(min_freq=1) 146 | # create_alphabet.createAlphabet(train_data=train_data, dev_data=dev_data, test_data=test_data, debug_index=-1) 147 | # load_data.loaddate("../pos_test_data/test.ctb60.pos.hwc") 148 | -------------------------------------------------------------------------------- /loaddata/Dataloader_normal.py: -------------------------------------------------------------------------------- 1 | # coding=utf-8 2 | 3 | import os 4 | import re 5 | import torch 6 | import shutil 7 | import random 8 | import unicodedata 9 | from loaddata.Alphabet import Create_Alphabet 10 | from loaddata.Instance import instance 11 | from loaddata.common import sep, app, paddingkey, unkkey, nullkey, label 12 | # fix the random seed 13 | import hyperparams as hy 14 | torch.manual_seed(hy.seed_num) 15 | random.seed(hy.seed_num) 16 | 17 | 18 | class load_data(): 19 | 20 | def __init__(self, path=[], shuffle=False): 21 | print("load data for train/dev/test") 22 | self.debug_index = -1 23 | self.path = path 24 | self.date_list = [] 25 | 26 | def clean_str(self, string): 27 | """ 28 | Tokenization/string cleaning for all datasets except for SST. 29 | Original taken from https://github.com/yoonkim/CNN_sentence/blob/master/process_data.py 30 | """ 31 | string = re.sub(r"[^A-Za-z0-9(),!?\'\`]", " ", string) 32 | string = re.sub(r"\'s", " \'s", string) 33 | string = re.sub(r"\'ve", " \'ve", string) 34 | string = re.sub(r"n\'t", " n\'t", string) 35 | string = re.sub(r"\'re", " \'re", string) 36 | string = re.sub(r"\'d", " \'d", string) 37 | string = re.sub(r"\'ll", " \'ll", string) 38 | string = re.sub(r",", " , ", string) 39 | string = re.sub(r"!", " ! ", string) 40 | string = re.sub(r"\(", " \( ", string) 41 | string = re.sub(r"\)", " \) ", string) 42 | string = re.sub(r"\?", " \? ", string) 43 | string = re.sub(r"\s{2,}", " ", string) 44 | return string.strip() 45 | 46 | def load_data(self, path=None, shuffle=False): 47 | assert isinstance(path, list), "path must be in list" 48 | for id_data in range(len(path)): 49 | print(path[id_data]) 50 | # insts = None 51 | insts = self.load_one_date(path=path[id_data], shuffle=shuffle) 52 | self.date_list.append(insts) 53 | return self.date_list[0], self.date_list[1], self.date_list[2] 54 | 55 | def load_one_date(self, path=None, shuffle=False): 56 | print("loading {} data......".format(path)) 57 | assert path is not None 58 | insts = [] 59 | with open(path, encoding="UTF-8") as f: 60 | lines = f.readlines() 61 | for index, line in enumerate(lines): 62 | # copy with "/n" 63 | if line is None: 64 | continue 65 | line = unicodedata.normalize('NFKC', line.strip()) 66 | # init instance 67 | inst = instance() 68 | line = line.split(" ") 69 | count = 0 70 | for word in line: 71 | # segment the word and pos in line 72 | # segment with tab space 73 | # word, _, _ = word_pos.partition(" ") 74 | word_length = len(word) 75 | inst.words.append(word) 76 | inst.gold_seg.append("[" + str(count) + "," + str(count + word_length) + "]") 77 | inst.gold_pos.append("[" + str(count) + "," + str(count + word_length) + "]" + label) 78 | count += word_length 79 | for i in range(word_length): 80 | char = word[i] 81 | # print(char) 82 | inst.chars.append(char) 83 | if i == 0: 84 | inst.gold.append(sep + "#" + label) 85 | inst.pos.append(label) 86 | else: 87 | inst.gold.append(app) 88 | char_number = len(inst.chars) 89 | for i in range(char_number): 90 | # copy with the left bichars 91 | if i is 0: 92 | inst.bichars_left.append(nullkey + inst.chars[i]) 93 | else: 94 | inst.bichars_left.append(inst.chars[i - 1] + inst.chars[i]) 95 | # copy with the right bichars 96 | if i == char_number - 1: 97 | inst.bichars_right.append(inst.chars[i] + nullkey) 98 | else: 99 | inst.bichars_right.append(inst.chars[i] + inst.chars[i + 1]) 100 | # char/word size 101 | inst.chars_size = len(inst.chars) 102 | inst.words_size = len(inst.words) 103 | inst.bichars_size = len(inst.bichars_left) 104 | inst.gold_size = len(inst.gold) 105 | # add one inst that represent one sentence into the list 106 | insts.append(inst) 107 | if index == self.debug_index: 108 | break 109 | if shuffle is True: 110 | print("shuffle tha data......") 111 | random.shuffle(insts) 112 | # return all sentence in data 113 | # print(insts[-1].words) 114 | return insts 115 | 116 | 117 | if __name__ == "__main__": 118 | print("Test dataloader........") 119 | loaddata = load_data() 120 | # train_data, dev_data, test_data = loaddata.load_data(path=("../pos_test_data/train.ctb60.pos-1.hwc", "../pos_test_data/dev.ctb60.pos.hwc", 121 | # "../pos_test_data/test.ctb60.pos.hwc"), shuffle=True) 122 | train_data, dev_data, test_data = loaddata.load_data(path=["../pos_test_data/train.ctb60.pos-1.hwc", "../pos_test_data/train.ctb60.pos-1.hwc" 123 | , "../pos_test_data/train.ctb60.pos-1.hwc"], shuffle=True) 124 | 125 | -------------------------------------------------------------------------------- /loaddata/Instance.py: -------------------------------------------------------------------------------- 1 | # coding=utf-8 2 | import torch 3 | import random 4 | import hyperparams as hy 5 | torch.manual_seed(hy.seed_num) 6 | random.seed(hy.seed_num) 7 | 8 | """ 9 | init instance 10 | """ 11 | 12 | 13 | class instance(): 14 | 15 | def __init__(self): 16 | # print("init instance......") 17 | 18 | self.words = [] 19 | self.words_size = 0 20 | self.chars = [] 21 | self.chars_size = 0 22 | self.bichars_left = [] 23 | self.bichars_right = [] 24 | self.bichars_size = 0 25 | 26 | self.gold = [] 27 | self.pos = [] 28 | self.gold_pos = [] 29 | self.gold_seg = [] 30 | self.gold_size = 0 31 | 32 | self.words_index = [] 33 | self.chars_index = [] 34 | self.bichars_left_index = [] 35 | self.bichars_right_index = [] 36 | self.static_chars_index = [] 37 | self.static_bichars_left_index = [] 38 | self.static_bichars_right_index = [] 39 | self.pos_index = [] 40 | self.gold_index = [] 41 | 42 | 43 | class Batch_Features: 44 | def __init__(self): 45 | 46 | self.batch_length = 0 47 | self.inst = None 48 | self.word_features = 0 49 | self.pos_features = 0 50 | self.char_features = 0 51 | self.bichar_left_features = 0 52 | self.bichar_right_features = 0 53 | self.static_char_features = 0 54 | self.static_bichar_left_features = 0 55 | self.static_bichar_right_features = 0 56 | self.gold_features = 0 57 | 58 | def cuda(self, features): 59 | features.word_features = features.word_features.cuda() 60 | features.pos_features = features.pos_features.cuda() 61 | features.char_features = features.char_features.cuda() 62 | features.static_char_features = features.static_char_features.cuda() 63 | features.bichar_left_features = features.bichar_left_features.cuda() 64 | features.static_bichar_left_features = features.static_bichar_left_features.cuda() 65 | features.bichar_right_features = features.bichar_right_features.cuda() 66 | features.static_bichar_right_features = features.static_bichar_right_features.cuda() 67 | features.gold_features = features.gold_features.cuda() 68 | 69 | -------------------------------------------------------------------------------- /loaddata/Load_external_word_embedding.py: -------------------------------------------------------------------------------- 1 | # coding=utf-8 2 | import torch 3 | import random 4 | import collections 5 | import numpy as np 6 | import tqdm as tqdm 7 | import gc 8 | import hyperparams as hy 9 | torch.manual_seed(hy.seed_num) 10 | random.seed(hy.seed_num) 11 | 12 | """ 13 | load external word embedding 14 | """ 15 | 16 | 17 | class Word_Embedding(): 18 | def __init__(self): 19 | print("loading external word embedding") 20 | self.test = 0 21 | 22 | # load word embedding 23 | def load_my_vecs(self, path, vocab, freqs, k=None): 24 | # word_vecs = {} 25 | word_vecs = collections.OrderedDict() 26 | with open(path, encoding="utf-8") as f: 27 | iov_count = 0 28 | words = [] 29 | lines = f.readlines() 30 | try: 31 | word_embedding_dim = int(lines[0]) 32 | except: 33 | print("ERROR: the word embedding file first line must be dim") 34 | exit() 35 | 36 | # lines_pbar = tqdm.tqdm(lines[1:]) 37 | lines_pbar = tqdm.tqdm(lines) 38 | # for line in lines[1:]: 39 | # for line, line_pbar in zip(lines, lines_pbar): 40 | for line in lines_pbar: 41 | lines_pbar.set_description("Processing") 42 | values = line.split(" ") 43 | word = values[0] 44 | # if word in words: 45 | # continue 46 | words.append(word) 47 | 48 | vocabs_pbar = tqdm.tqdm(vocab) 49 | # for vocab_word in vocab: 50 | # for vocab_word, vocab_pbar in zip(vocab, vocabs_pbar): 51 | for vocab_word in vocabs_pbar: 52 | vocabs_pbar.set_description("Processing") 53 | if vocab_word in words: 54 | words_index = words.index(vocab_word) 55 | iov_count += 1 56 | values = lines[words_index].split(" ") 57 | vector = [] 58 | for count, val in enumerate(values): 59 | if count == 0: 60 | continue 61 | if count <= k: 62 | vector.append(float(val)) 63 | word_vecs[vocab_word] = vector 64 | 65 | print("iov count {}".format(iov_count)) 66 | print("oov count {}".format(len(vocab) - iov_count)) 67 | return word_vecs 68 | 69 | 70 | # load word embedding 71 | def load_my_vecs_version_2(self, path, vocab, freqs, k=None): 72 | # word_vecs = {} 73 | word_vecs = collections.OrderedDict() 74 | with open(path, encoding="utf-8") as f: 75 | iov_count = 0 76 | words = [] 77 | lines = f.readlines() 78 | try: 79 | word_embedding_dim = int(lines[0]) 80 | except: 81 | print("ERROR: the word embedding file first line must be dim") 82 | exit() 83 | 84 | # lines_pbar = tqdm.tqdm(lines[1:]) 85 | lines_pbar = tqdm.tqdm(lines) 86 | # for line in lines[1:]: 87 | # for line, line_pbar in zip(lines, lines_pbar): 88 | for line in lines_pbar: 89 | lines_pbar.set_description("Processing") 90 | values = line.split(" ") 91 | word = values[0] 92 | # if word in words: 93 | # continue 94 | words.append(word) 95 | 96 | 97 | vocabs_pbar = tqdm.tqdm(vocab) 98 | # for vocab_word in vocab: 99 | # for vocab_word, vocab_pbar in zip(vocab, vocabs_pbar): 100 | for vocab_word in vocabs_pbar: 101 | vocabs_pbar.set_description("Processing") 102 | for words_index, words_word in enumerate(words): 103 | if vocab_word == words_word: 104 | iov_count += 1 105 | values = lines[words_index].split(" ") 106 | vector = [] 107 | for count, val in enumerate(values): 108 | if count == 0: 109 | continue 110 | if count <= k: 111 | vector.append(float(val)) 112 | word_vecs[vocab_word] = vector 113 | break 114 | print("iov count {}".format(iov_count)) 115 | print("oov count {}".format(len(vocab) - iov_count)) 116 | return word_vecs 117 | 118 | def load_my_vecs_version_1(self, path, vocab, freqs, k=None): 119 | word_vecs = {} 120 | with open(path, encoding="utf-8") as f: 121 | count = 0 122 | lines = f.readlines() 123 | try: 124 | word_embedding_dim = int(lines[0]) 125 | except: 126 | print("ERROR: the word embedding file first line must be dim") 127 | exit() 128 | for line in lines[1:]: 129 | values = line.split(" ") 130 | word = values[0] 131 | # word = word.lower() 132 | # if word in vocab and freqs[word] != 1: # whether to judge if in vocab 133 | count += 1 134 | if word in vocab: # whether to judge if in vocab 135 | # if word in vocab: # whether to judge if in vocab 136 | # if count % 5 == 0 and freqs[word] == 1: 137 | # continue 138 | vector = [] 139 | for count, val in enumerate(values): 140 | if count == 0: 141 | continue 142 | if count <= k: 143 | vector.append(float(val)) 144 | word_vecs[word] = vector 145 | return word_vecs 146 | 147 | # solve unknown by avg word embedding 148 | def add_unknown_words_by_avg(self, word_vecs, vocab, k=100): 149 | # solve unknown words inplaced by zero list 150 | word_vecs_numpy = [] 151 | for word in vocab: 152 | if word in word_vecs: 153 | word_vecs_numpy.append(word_vecs[word]) 154 | # print(len(word_vecs_numpy)) 155 | col = [] 156 | for i in range(k): 157 | sum = 0.0 158 | # for j in range(int(len(word_vecs_numpy) / 4)): 159 | for j in range(int(len(word_vecs_numpy))): 160 | sum += word_vecs_numpy[j][i] 161 | sum = round(sum, 6) 162 | col.append(sum) 163 | zero = [] 164 | for m in range(k): 165 | # avg = col[m] / (len(col) * 5) 166 | avg = col[m] / (len(word_vecs_numpy)) 167 | avg = round(avg, 6) 168 | zero.append(float(avg)) 169 | 170 | # print("zero", zero) 171 | 172 | list_word2vec = [] 173 | oov = 0 174 | iov = 0 175 | for word in vocab: 176 | if word not in word_vecs: 177 | # word_vecs[word] = np.random.uniform(-0.25, 0.25, k).tolist() 178 | # word_vecs[word] = [0.0] * k 179 | oov += 1 180 | word_vecs[word] = zero 181 | list_word2vec.append(word_vecs[word]) 182 | else: 183 | iov += 1 184 | list_word2vec.append(word_vecs[word]) 185 | print("oov count", oov) 186 | print("iov count", iov) 187 | return list_word2vec 188 | 189 | # solve unknown word by uniform(-0.25,0.25) 190 | def add_unknown_words_by_uniform(self, word_vecs, vocab, k=100): 191 | list_word2vec = [] 192 | oov = 0 193 | iov = 0 194 | # uniform = np.random.uniform(-0.25, 0.25, k).round(6).tolist() 195 | for word in vocab: 196 | if word not in word_vecs: 197 | oov += 1 198 | word_vecs[word] = np.random.uniform(-0.25, 0.25, k).round(6).tolist() 199 | # word_vecs[word] = np.random.uniform(-0.1, 0.1, k).round(6).tolist() 200 | # word_vecs[word] = uniform 201 | list_word2vec.append(word_vecs[word]) 202 | else: 203 | iov += 1 204 | list_word2vec.append(word_vecs[word]) 205 | print("oov count", oov) 206 | print("iov count", iov) 207 | print("all words", oov + iov) 208 | return list_word2vec 209 | 210 | # load word embedding 211 | def load_my_vecs_freq1(self, path, vocab, freqs, pro): 212 | word_vecs = {} 213 | with open(path, encoding="utf-8") as f: 214 | freq = 0 215 | lines = f.readlines()[1:] 216 | for line in lines: 217 | values = line.split(" ") 218 | word = values[0] 219 | if word in vocab: # whehter to judge if in vocab 220 | if freqs[word] == 1: 221 | a = np.random.uniform(0, 1, 1).round(2) 222 | if pro < a: 223 | continue 224 | vector = [] 225 | for count, val in enumerate(values): 226 | if count == 0: 227 | continue 228 | vector.append(float(val)) 229 | word_vecs[word] = vector 230 | return word_vecs 231 | -------------------------------------------------------------------------------- /loaddata/Load_pretrain.py: -------------------------------------------------------------------------------- 1 | # coding=utf-8 2 | """ 3 | load pretrain 4 | """ 5 | 6 | import torch 7 | import torch.nn.init as init 8 | import numpy as np 9 | import random 10 | import torch.nn as nn 11 | import hyperparams as hy 12 | torch.manual_seed(hy.seed_num) 13 | random.seed(hy.seed_num) 14 | 15 | 16 | class Load_Pretrain: 17 | 18 | def __init__(self): 19 | print("loading pretrain") 20 | 21 | def load_pretrain(self, file, alpha, unk, padding): 22 | f = open(file, encoding='utf-8') 23 | allLines = f.readlines() 24 | # allLines = f.readlines()[1:] 25 | indexs = set() 26 | info = allLines[0].strip().split(' ') 27 | embDim = len(info) - 1 28 | emb = nn.Embedding(alpha.m_size, embDim) 29 | 30 | init.uniform(emb.weight, a=-np.sqrt(3 / embDim), b=np.sqrt(3 / embDim)) 31 | oov_emb = torch.zeros(1, embDim).type(torch.FloatTensor) 32 | 33 | for line in allLines: 34 | info = line.split(' ') 35 | wordID = alpha.loadWord2idAndId2Word(info[0]) 36 | if wordID >= 0: 37 | indexs.add(wordID) 38 | for idx in range(embDim): 39 | val = float(info[idx + 1]) 40 | emb.weight.data[wordID][idx] = val 41 | oov_emb[0][idx] += val 42 | f.close() 43 | count = len(indexs) + 1 44 | for idx in range(embDim): 45 | oov_emb[0][idx] /= count 46 | unkID = alpha.loadWord2idAndId2Word(unk) 47 | paddingID = alpha.loadWord2idAndId2Word(padding) 48 | for idx in range(embDim): 49 | emb.weight.data[paddingID][idx] = 0 50 | # print('UNK ID: ', unkID) 51 | # print('Padding ID: ', paddingID) 52 | if unkID != -1: 53 | for idx in range(embDim): 54 | emb.weight.data[unkID][idx] = oov_emb[0][idx] 55 | print("Load Embedding file: ", file, ", size: ", embDim) 56 | oov = 0 57 | for idx in range(alpha.m_size): 58 | if idx not in indexs: 59 | oov += 1 60 | print("oov: ", oov, " total: ", alpha.m_size, "oov ratio: ", oov / alpha.m_size) 61 | print("oov ", unk, "use avg value initialize") 62 | return emb, embDim 63 | 64 | 65 | -------------------------------------------------------------------------------- /loaddata/__pycache__/Alphabet.cpython-36.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dalinvip/PyTorch_Chinese_word_segmentation/d17594729c6fe7e9ae6fe3d1e8c7614ed0a2ef82/loaddata/__pycache__/Alphabet.cpython-36.pyc -------------------------------------------------------------------------------- /loaddata/__pycache__/Batch_Iterator.cpython-36.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dalinvip/PyTorch_Chinese_word_segmentation/d17594729c6fe7e9ae6fe3d1e8c7614ed0a2ef82/loaddata/__pycache__/Batch_Iterator.cpython-36.pyc -------------------------------------------------------------------------------- /loaddata/__pycache__/Dataloader.cpython-36.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dalinvip/PyTorch_Chinese_word_segmentation/d17594729c6fe7e9ae6fe3d1e8c7614ed0a2ef82/loaddata/__pycache__/Dataloader.cpython-36.pyc -------------------------------------------------------------------------------- /loaddata/__pycache__/Instance.cpython-36.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dalinvip/PyTorch_Chinese_word_segmentation/d17594729c6fe7e9ae6fe3d1e8c7614ed0a2ef82/loaddata/__pycache__/Instance.cpython-36.pyc -------------------------------------------------------------------------------- /loaddata/__pycache__/Load_external_word_embedding.cpython-36.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dalinvip/PyTorch_Chinese_word_segmentation/d17594729c6fe7e9ae6fe3d1e8c7614ed0a2ef82/loaddata/__pycache__/Load_external_word_embedding.cpython-36.pyc -------------------------------------------------------------------------------- /loaddata/__pycache__/common.cpython-36.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dalinvip/PyTorch_Chinese_word_segmentation/d17594729c6fe7e9ae6fe3d1e8c7614ed0a2ef82/loaddata/__pycache__/common.cpython-36.pyc -------------------------------------------------------------------------------- /loaddata/common.py: -------------------------------------------------------------------------------- 1 | # coding=utf-8 2 | import torch 3 | import random 4 | import hyperparams as hy 5 | torch.manual_seed(hy.seed_num) 6 | random.seed(hy.seed_num) 7 | 8 | unkkey = '-unk-' 9 | nullkey = '-NULL-' 10 | paddingkey = '-padding-' 11 | sep = 'SEP' 12 | app = 'APP' 13 | label = "NN" -------------------------------------------------------------------------------- /loaddata/handle_wordEmbedding2File.py: -------------------------------------------------------------------------------- 1 | # coding=utf-8 2 | 3 | """ 4 | handle external word embedding to file 5 | """ 6 | import torch 7 | import os 8 | class WordEmbedding2File: 9 | def __init__(self, wordEmbedding_path=None, vocab=None, k_dim=100): 10 | print("handling external word embedding to file") 11 | self.wordEmbedding_path = wordEmbedding_path 12 | self.vocab = vocab 13 | self.k_dim = k_dim 14 | 15 | def handle(self): 16 | if os.path.exists("./convert-bichar.txt"): 17 | os.remove("./convert-bichar.txt") 18 | file = open("./convert-bichar.txt", "w") 19 | with open(self.wordEmbedding_path, encoding="utf-8") as f: 20 | count = 0 21 | lines = f.readlines() 22 | file.write(str(self.k_dim)) 23 | file.write("\n") 24 | for line in lines: 25 | values = line.split(" ") 26 | word = values[0] 27 | if word in self.vocab: 28 | count += 1 29 | print(line) 30 | file.writelines(line) 31 | else: 32 | print("******************************") 33 | print("The number of handle is {} ".format(count)) 34 | file.close() 35 | print("Handle external word embedding has Finished.") 36 | 37 | 38 | 39 | -------------------------------------------------------------------------------- /main_hyperparams.py: -------------------------------------------------------------------------------- 1 | #! /usr/bin/env python 2 | import os 3 | import argparse 4 | import datetime 5 | import torch 6 | from loaddata.Load_external_word_embedding import Word_Embedding 7 | from loaddata.Dataloader import load_data, instance 8 | from loaddata.Alphabet import Create_Alphabet, Alphabet 9 | from loaddata.Batch_Iterator import Iterators 10 | from models import decoder_wordlstm_batch 11 | from models import encoder_wordlstm 12 | from models import encoder_wordlstmcell 13 | import train_seq2seq_wordlstm_batch 14 | import multiprocessing as mu 15 | import shutil 16 | import random 17 | import hyperparams 18 | import hyperparams as hy 19 | import time 20 | # solve encoding 21 | from imp import reload 22 | import sys 23 | defaultencoding = 'utf-8' 24 | if sys.getdefaultencoding() != defaultencoding: 25 | reload(sys) 26 | sys.setdefaultencoding(defaultencoding) 27 | 28 | # init hyperparams instance 29 | hyperparams = hyperparams.Hyperparams() 30 | 31 | # random seed 32 | torch.manual_seed(hy.seed_num) 33 | random.seed(hy.seed_num) 34 | 35 | parser = argparse.ArgumentParser(description="Chinese word segmentation") 36 | # learning 37 | parser.add_argument('-lr', type=float, default=hyperparams.learning_rate, help='initial learning rate [default: 0.001]') 38 | parser.add_argument('-learning_rate_decay', type=float, default=hyperparams.learning_rate_decay, help='initial learning_rate_decay rate [default: 0.001]') 39 | parser.add_argument('-epochs', type=int, default=hyperparams.epochs, help='number of epochs for train [default: 256]') 40 | parser.add_argument('-batch-size', type=int, default=hyperparams.train_batch_size, help='batch size for training [default: 64]') 41 | parser.add_argument('-dev-batch-size', type=int, default=hyperparams.dev_batch_size, help='batch size for training [default: 64]') 42 | parser.add_argument('-test-batch-size', type=int, default=hyperparams.test_batch_size, help='batch size for training [default: 64]') 43 | parser.add_argument('-log-interval', type=int, default=hyperparams.log_interval, help='how many steps to wait before logging training status [default: 1]') 44 | parser.add_argument('-dev-interval', type=int, default=hyperparams.dev_interval, help='how many steps to wait before testing [default: 100]') 45 | parser.add_argument('-test-interval', type=int, default=hyperparams.test_interval, help='how many steps to wait before saving [default:500]') 46 | parser.add_argument('-save-dir', type=str, default=hyperparams.save_dir, help='where to save the snapshot') 47 | # data path 48 | parser.add_argument('-train_path', type=str, default=hyperparams.train_path, help='train data path') 49 | parser.add_argument('-dev_path', type=str, default=hyperparams.dev_path, help='dev data path') 50 | parser.add_argument('-test_path', type=str, default=hyperparams.test_path, help='test data path') 51 | # shuffle data 52 | parser.add_argument('-shuffle', action='store_true', default=hyperparams.shuffle, help='shuffle the data when load data' ) 53 | parser.add_argument('-epochs_shuffle', action='store_true', default=hyperparams.epochs_shuffle, help='shuffle the data every epoch' ) 54 | # optim select 55 | parser.add_argument('-Adam', action='store_true', default=hyperparams.Adam, help='whether to select Adam to train') 56 | parser.add_argument('-SGD', action='store_true', default=hyperparams.SGD, help='whether to select SGD to train') 57 | parser.add_argument('-Adadelta', action='store_true', default=hyperparams.Adadelta, help='whether to select Adadelta to train') 58 | parser.add_argument('-momentum_value', type=float, default=hyperparams.optim_momentum_value, help='value of momentum in SGD') 59 | # model 60 | parser.add_argument('-rm_model', action='store_true', default=hyperparams.rm_model, help='whether to delete the model after test acc so that to save space') 61 | parser.add_argument('-init_weight', action='store_true', default=hyperparams.init_weight, help='init w') 62 | parser.add_argument('-init_weight_value', type=float, default=hyperparams.init_weight_value, help='value of init w') 63 | parser.add_argument('-init_weight_decay', type=float, default=hyperparams.weight_decay, help='value of init L2 weight_decay') 64 | parser.add_argument('-init_clip_max_norm', type=float, default=hyperparams.clip_max_norm, help='value of init clip_max_norm') 65 | parser.add_argument('-dropout', type=float, default=hyperparams.dropout, help='the probability for dropout [default: 0.5]') 66 | parser.add_argument('-dropout_embed', type=float, default=hyperparams.dropout_embed, help='the probability for dropout [default: 0.5]') 67 | parser.add_argument('-dropout_lstm', type=float, default=hyperparams.dropout_lstm, help='the probability for dropout [default: 0.5]') 68 | parser.add_argument('-max-norm', type=float, default=hyperparams.max_norm, help='l2 constraint of parameters [default: 3.0]') 69 | parser.add_argument('-embed-dim', type=int, default=hyperparams.embed_dim, help='number of embedding dimension [default: 128]') 70 | parser.add_argument('-static', action='store_true', default=hyperparams.static, help='fix the embedding') 71 | parser.add_argument('-Wordlstm', action='store_true', default=hyperparams.Wordlstm, help='whether to use Wordlstm decoder model') 72 | parser.add_argument('-Encoder_LSTM', action='store_true', default=hyperparams.Encoder_LSTM, help='whether to use BiLSTM_1 model') 73 | parser.add_argument('-Encoder_LSTMCell', action='store_true', default=hyperparams.Encoder_LSTMCell, help='whether to use LSTM model') 74 | parser.add_argument('-fix_Embedding', action='store_true', default=hyperparams.fix_Embedding, help='whether to fix word embedding during training') 75 | parser.add_argument('-word_Embedding', action='store_true', default=hyperparams.word_Embedding, help='whether to load word embedding') 76 | parser.add_argument('-word_Embedding_Path', type=str, default=hyperparams.word_Embedding_Path, help='filename of model snapshot [default: None]') 77 | parser.add_argument('-rnn_hidden_dim', type=int, default=hyperparams.rnn_hidden_dim, help='the number of embedding dimension in LSTM hidden layer') 78 | parser.add_argument('-rnn_num_layers', type=int, default=hyperparams.rnn_num_layers, help='the number of embedding dimension in LSTM hidden layer') 79 | parser.add_argument('-min_freq', type=int, default=hyperparams.min_freq, help='min freq to include during built the vocab') 80 | parser.add_argument('-word_min_freq', type=int, default=hyperparams.word_min_freq, help='word_min_freq') 81 | parser.add_argument('-char_min_freq', type=int, default=hyperparams.char_min_freq, help='char_min_freq') 82 | parser.add_argument('-bichar_min_freq', type=int, default=hyperparams.bichar_min_freq, help='bichar_min_freq') 83 | # encoder model and decoder model 84 | parser.add_argument('-embed_char_dim', type=int, default=hyperparams.embed_char_dim, help='number of char embedding dimension [default: 200]') 85 | parser.add_argument('-embed_bichar_dim', type=int, default=hyperparams.embed_bichar_dim, help='number of bichar embedding dimension [default: 200]') 86 | parser.add_argument('-hidden_size', type=int, default=hyperparams.hidden_size, help='hidden dimension [default: 200]') 87 | # word embedding 88 | parser.add_argument('-pos_dim', type=int, default=hyperparams.pos_dim, help='pos_dim') 89 | parser.add_argument('-char_Embedding', action='store_true', default=hyperparams.char_Embedding, help='whether to load char embedding') 90 | parser.add_argument('-char_Embedding_path', type=str, default=hyperparams.char_Embedding_path, help='char_Embedding_path') 91 | parser.add_argument('-bichar_Embedding', action='store_true', default=hyperparams.bichar_Embedding, help='whether to load bichar embedding') 92 | parser.add_argument('-bichar_Embedding_Path', type=str, default=hyperparams.bichar_Embedding_Path, help='bichar_Embedding_Path') 93 | # seed number 94 | parser.add_argument('-seed_num', type=float, default=hy.seed_num, help='value of init seed number') 95 | # nums of threads 96 | parser.add_argument('-num_threads', type=int, default=hyperparams.num_threads, help='the num of threads') 97 | # device 98 | parser.add_argument('-gpu_device', type=int, default=hyperparams.gpu_device, help='gpu number that usr in training') 99 | parser.add_argument('-use_cuda', action='store_true', default=hyperparams.use_cuda, help='disable the gpu') 100 | # option 101 | args = parser.parse_args() 102 | 103 | 104 | # load data / create alphabet / create iterator 105 | def dalaloader(args): 106 | print("loading data......") 107 | # read file 108 | data_loader = load_data() 109 | train_data, dev_data, test_data = data_loader.load_data(path=[args.train_path, args.dev_path, args.test_path], 110 | shuffle=args.shuffle) 111 | # print(train_data) 112 | # create the alphabet 113 | create_alphabet = Create_Alphabet(min_freq=args.min_freq, word_min_freq=args.word_min_freq, 114 | char_min_freq=args.char_min_freq, bichar_min_freq=args.bichar_min_freq) 115 | create_alphabet.createAlphabet(train_data=train_data) 116 | 117 | create_static_alphabet = Create_Alphabet(min_freq=args.min_freq, word_min_freq=args.min_freq, 118 | char_min_freq=args.min_freq, bichar_min_freq=args.min_freq) 119 | create_static_alphabet.createAlphabet(train_data=train_data, dev_data=dev_data, test_data=test_data) 120 | # create iterator 121 | create_iter = Iterators() 122 | train_iter, dev_iter, test_iter = create_iter.createIterator(batch_size=[args.batch_size, args.dev_batch_size, 123 | args.test_batch_size], 124 | data=[train_data, dev_data, test_data], 125 | operator=create_alphabet, 126 | operator_static=create_static_alphabet, args=args) 127 | return train_iter, dev_iter, test_iter, create_alphabet, create_static_alphabet 128 | 129 | 130 | # get iter 131 | train_iter, dev_iter, test_iter, create_alphabet, create_static_alphabet = dalaloader(args) 132 | 133 | 134 | if args.char_Embedding is True: 135 | print("loading char embedding.......") 136 | char_word_vecs_dict = Word_Embedding().load_my_vecs(path=args.char_Embedding_path, 137 | vocab=create_static_alphabet.char_alphabet.id2words, 138 | freqs=None, k=args.embed_char_dim) 139 | print("avg handle tha oov words") 140 | char_word_vecs = Word_Embedding().add_unknown_words_by_avg(word_vecs=char_word_vecs_dict, 141 | vocab=create_static_alphabet.char_alphabet.id2words, 142 | k=args.embed_char_dim) 143 | # char_word_vecs = Word_Embedding().add_unknown_words_by_uniform(word_vecs=char_word_vecs, 144 | # vocab=create_static_alphabet.char_alphabet.id2words, 145 | # k=args.embed_char_dim) 146 | # print(char_word_vecs) 147 | 148 | if args.bichar_Embedding is True: 149 | print("loading bichar embedding.......") 150 | bichar_word_vecs_dict = Word_Embedding().load_my_vecs(path=args.bichar_Embedding_Path, 151 | vocab=create_static_alphabet.bichar_alphabet.id2words, 152 | freqs=None, k=args.embed_bichar_dim) 153 | print("avg handle tha oov words") 154 | bichar_word_vecs = Word_Embedding().add_unknown_words_by_avg(word_vecs=bichar_word_vecs_dict, 155 | vocab=create_static_alphabet.bichar_alphabet.id2words, 156 | k=args.embed_bichar_dim) 157 | # bichar_word_vecs = Word_Embedding().add_unknown_words_by_uniform(word_vecs=bichar_word_vecs, 158 | # vocab=create_static_alphabet.bichar_alphabet.id2words, 159 | # k=args.embed_bichar_dim) 160 | # print(bichar_word_vecs) 161 | 162 | # # handle external word embedding to file for convenience 163 | # from loaddata.handle_wordEmbedding2File import WordEmbedding2File 164 | # wordembedding = WordEmbedding2File(wordEmbedding_path=args.bichar_Embedding_Path, 165 | # vocab=create_static_alphabet.bichar_alphabet.id2words, k_dim=200) 166 | # wordembedding.handle() 167 | 168 | # update parameters 169 | if args.char_Embedding is True: 170 | args.pre_char_word_vecs = char_word_vecs 171 | if args.bichar_Embedding is True: 172 | args.pre_bichar_word_vecs = bichar_word_vecs 173 | 174 | args.use_cuda = (args.use_cuda) and torch.cuda.is_available() 175 | 176 | args.embed_char_num = create_alphabet.char_alphabet.m_size 177 | args.embed_bichar_num = create_alphabet.bichar_alphabet.m_size 178 | args.static_embed_char_num = create_static_alphabet.char_alphabet.m_size 179 | args.static_embed_bichar_num = create_static_alphabet.bichar_alphabet.m_size 180 | print("create_alphabet.char_alphabet.m_size", create_alphabet.char_alphabet.m_size) 181 | print("create_static_alphabet.char_alphabet.m_size", create_static_alphabet.char_alphabet.m_size) 182 | 183 | 184 | args.label_size = create_alphabet.label_alphabet.m_size 185 | args.pos_size = create_alphabet.pos_alphabet.m_size 186 | 187 | args.create_alphabet = create_alphabet 188 | args.create_static_alphabet = create_static_alphabet 189 | # save file 190 | mulu = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S') 191 | args.mulu = mulu 192 | args.save_dir = os.path.join(args.save_dir, mulu) 193 | if not os.path.isdir(args.save_dir): 194 | os.makedirs(args.save_dir) 195 | 196 | 197 | # print parameters 198 | print("\nParameters:") 199 | if os.path.exists("./Parameters.txt"): 200 | os.remove("./Parameters.txt") 201 | file = open("Parameters.txt", "a") 202 | for attr, value in sorted(args.__dict__.items()): 203 | # if attr.upper() != "PRE_CHAR_WORD_VECS" and attr.upper() != "PRE_BICHAR_WORD_VECS": 204 | # print("\t{}={}".format(attr.upper(), value)) 205 | if attr.upper() == "PRE_CHAR_WORD_VECS" or attr.upper() == "PRE_BICHAR_WORD_VECS": 206 | continue 207 | print("\t{}={}".format(attr.upper(), value)) 208 | file.write("\t{}={}\n".format(attr.upper(), value)) 209 | file.close() 210 | shutil.copy("./Parameters.txt", "./snapshot/" + mulu + "/Parameters.txt") 211 | shutil.copy("./hyperparams.py", "./snapshot/" + mulu) 212 | 213 | 214 | # load model 215 | model_encoder = None 216 | model_decoder = None 217 | # wordlstm and batch 218 | if args.Wordlstm is True: 219 | print("loading word lstm decoder model") 220 | model_decoder = decoder_wordlstm_batch.Decoder_WordLstm(args=args) 221 | if args.Encoder_LSTM is True: 222 | model_encoder = encoder_wordlstm.Encoder_WordLstm(args) 223 | elif args.Encoder_LSTMCell is True: 224 | model_encoder = encoder_wordlstmcell.Encoder_WordLstm(args) 225 | else: 226 | print("please choose Wordlstm is True......") 227 | print(model_encoder) 228 | print(model_decoder) 229 | if args.use_cuda is True: 230 | print("using cuda......") 231 | model_encoder = model_encoder.cuda() 232 | model_decoder = model_decoder.cuda() 233 | 234 | # train 235 | print("\n CPU Count is {} and Current Process is {} \n".format(mu.cpu_count(), mu.current_process())) 236 | # set thread number 237 | torch.set_num_threads(args.num_threads) 238 | print("train_seq2seq_wordlstm") 239 | train_seq2seq_wordlstm_batch.train(train_iter=train_iter, dev_iter=dev_iter, test_iter=test_iter, 240 | model_encoder=model_encoder, 241 | model_decoder=model_decoder, args=args) 242 | 243 | 244 | -------------------------------------------------------------------------------- /models/__pycache__/decoder_wordlstm_batch.cpython-36.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dalinvip/PyTorch_Chinese_word_segmentation/d17594729c6fe7e9ae6fe3d1e8c7614ed0a2ef82/models/__pycache__/decoder_wordlstm_batch.cpython-36.pyc -------------------------------------------------------------------------------- /models/__pycache__/encoder_wordlstm.cpython-36.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dalinvip/PyTorch_Chinese_word_segmentation/d17594729c6fe7e9ae6fe3d1e8c7614ed0a2ef82/models/__pycache__/encoder_wordlstm.cpython-36.pyc -------------------------------------------------------------------------------- /models/__pycache__/encoder_wordlstmcell.cpython-36.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dalinvip/PyTorch_Chinese_word_segmentation/d17594729c6fe7e9ae6fe3d1e8c7614ed0a2ef82/models/__pycache__/encoder_wordlstmcell.cpython-36.pyc -------------------------------------------------------------------------------- /models/decoder_wordlstm_batch.py: -------------------------------------------------------------------------------- 1 | # coding=utf-8 2 | from loaddata.common import paddingkey, app 3 | import torch.nn 4 | import torch.nn as nn 5 | import torch.nn.functional as F 6 | from torch.autograd import Variable 7 | import torch.nn.init as init 8 | import numpy as np 9 | import random 10 | from state import state_instance 11 | from state import state_batch_instance 12 | import hyperparams as hy 13 | torch.manual_seed(hy.seed_num) 14 | random.seed(hy.seed_num) 15 | 16 | """ 17 | sequence to sequence Decoder model 18 | """ 19 | 20 | 21 | class Decoder_WordLstm(nn.Module): 22 | 23 | def __init__(self, args): 24 | print("Decoder model") 25 | super(Decoder_WordLstm, self).__init__() 26 | self.args = args 27 | 28 | self.pos_paddingKey = self.args.create_alphabet.pos_PaddingID 29 | print("pos_paddingKey", self.pos_paddingKey) 30 | print("appID", self.args.create_alphabet.appID) 31 | 32 | # self.lstm = nn.LSTM(input_size=self.args.hidden_size, hidden_size=self.args.rnn_hidden_dim, bias=True) 33 | self.lstmcell = nn.LSTMCell(input_size=self.args.hidden_size, hidden_size=self.args.rnn_hidden_dim, bias=True) 34 | init.xavier_uniform(self.lstmcell.weight_ih) 35 | init.xavier_uniform(self.lstmcell.weight_hh) 36 | self.lstmcell.bias_hh.data.uniform_(-np.sqrt(6 / (self.args.rnn_hidden_dim + 1)), 37 | np.sqrt(6 / (self.args.rnn_hidden_dim + 1))) 38 | self.lstmcell.bias_ih.data.uniform_(-np.sqrt(6 / (self.args.rnn_hidden_dim + 1)), 39 | np.sqrt(6 / (self.args.rnn_hidden_dim + 1))) 40 | 41 | # self.pos_embed = nn.Embedding(num_embeddings=self.args.pos_size, embedding_dim=self.args.pos_dim, 42 | # padding_idx=self.pos_paddingKey) 43 | self.pos_embed = nn.Embedding(num_embeddings=self.args.pos_size, embedding_dim=self.args.pos_dim) 44 | init.uniform(self.pos_embed.weight, 45 | a=-np.sqrt(3 / self.args.pos_dim), 46 | b=np.sqrt(3 / self.args.pos_dim)) 47 | for i in range(self.args.pos_dim): 48 | self.pos_embed.weight.data[self.pos_paddingKey][i] = 0 49 | self.pos_embed.weight.requires_grad = True 50 | 51 | self.linear = nn.Linear(in_features=self.args.rnn_hidden_dim * 2 + self.args.hidden_size, 52 | out_features=self.args.label_size, bias=False) 53 | 54 | # self.non_linear = nn.Linear(in_features=self.args.rnn_hidden_dim * 2, out_features=self.args.hidden_size, 55 | # bias=True) 56 | 57 | self.combine_linear = nn.Linear(in_features=self.args.rnn_hidden_dim * 2 + self.args.pos_dim, 58 | out_features=self.args.hidden_size, bias=True) 59 | 60 | init.xavier_uniform(self.linear.weight) 61 | # init.xavier_uniform(self.non_linear.weight) 62 | init.xavier_uniform(self.combine_linear.weight) 63 | # self.non_linear.bias.data.uniform_(-np.sqrt(6 / (self.args.hidden_size + 1)), 64 | # np.sqrt(6 / (self.args.hidden_size + 1))) 65 | self.combine_linear.bias.data.uniform_(-np.sqrt(6 / (self.args.hidden_size + 1)), 66 | np.sqrt(6 / (self.args.hidden_size + 1))) 67 | 68 | self.dropout = nn.Dropout(self.args.dropout) 69 | 70 | self.softmax = nn.LogSoftmax(dim=1) 71 | 72 | self.bucket = Variable(torch.zeros(1, self.args.label_size)) 73 | self.bucket_rnn = Variable(torch.zeros(1, self.args.rnn_hidden_dim)) 74 | if self.args.use_cuda is True: 75 | self.bucket = self.bucket.cuda() 76 | self.bucket_rnn = self.bucket_rnn.cuda() 77 | 78 | def init_hidden_cell(self, batch_size): 79 | z_bucket = Variable(torch.zeros(batch_size, self.args.hidden_size)) 80 | h_bucket = Variable(torch.zeros(batch_size, self.args.rnn_hidden_dim)) 81 | c_bucket = Variable(torch.zeros(batch_size, self.args.rnn_hidden_dim)) 82 | if self.args.use_cuda is True: 83 | z_bucket = z_bucket.cuda() 84 | h_bucket = h_bucket.cuda() 85 | c_bucket = c_bucket.cuda() 86 | return h_bucket, c_bucket, z_bucket 87 | 88 | def forward(self, features, encoder_out, train=False): 89 | 90 | batch_length = features.batch_length 91 | encoder_out = encoder_out.permute(1, 0, 2) 92 | char_features_num = encoder_out.size(0) 93 | state = state_batch_instance(features, char_features_num) 94 | # state.show() 95 | char_output = [] 96 | for id_char in range(char_features_num): 97 | h_now, c_now = self.batch_wordLstm(id_char, batch_length, encoder_out, state) 98 | 99 | v = torch.cat((h_now, encoder_out[id_char]), 1) 100 | # print(v) 101 | output = self.linear(v) 102 | if id_char is 0: 103 | for i in range(batch_length): 104 | output.data[i][self.args.create_alphabet.appID] = -10e9 105 | self.batch_action(state, id_char, output, h_now, c_now, batch_length, train) 106 | char_output.append(output.unsqueeze(1)) 107 | decoder_out = torch.cat(char_output, 1) 108 | decoder_out = decoder_out.view(batch_length * char_features_num, -1) 109 | decoder_out = self.softmax(decoder_out) 110 | return decoder_out, state 111 | 112 | def batch_wordLstm_1(self, id_char, batch_length, encoder_out, state): 113 | if id_char is 0: 114 | h, c, z = self.init_hidden_cell(batch_length) 115 | else: 116 | h, c = state.word_hiddens[-1], state.word_cells[-1] 117 | # copy with the pos features 118 | last_pos = Variable(torch.zeros(batch_length)).type(torch.LongTensor) 119 | if self.args.use_cuda is True: last_pos = last_pos.cuda() 120 | pos_id_array = np.array(state.pos_id[-1]) 121 | last_pos.data.copy_(torch.from_numpy(pos_id_array)) 122 | # print(last_pos) 123 | last_pos_embed = self.dropout(self.pos_embed(last_pos)) 124 | 125 | # copy with the word features 126 | batch_char_embed = [] 127 | for id_batch in range(len(state.words_startindex[-1])): 128 | chars_embed = [] 129 | last_word_len = 0 130 | if state.words_startindex[-1][id_batch] is -1: 131 | word_bucket = Variable(torch.zeros(1, 2 * self.args.rnn_hidden_dim)) 132 | if self.args.use_cuda is True: 133 | word_bucket = word_bucket.cuda() 134 | batch_char_embed.append(word_bucket) 135 | continue 136 | for index_char in range(state.words_startindex[-1][id_batch], id_char): 137 | last_word_len += 1 138 | chars_embed.append(encoder_out[index_char][id_batch].view(1, 1, 2 * self.args.rnn_hidden_dim)) 139 | chars_embed = torch.cat(chars_embed, 1) 140 | last_word_embed = F.avg_pool1d(chars_embed.permute(0, 2, 1), last_word_len).view(1, self.args.rnn_hidden_dim * 2) 141 | batch_char_embed.append(last_word_embed) 142 | batch_char_embed = torch.cat(batch_char_embed, 0) 143 | # print("batch_char_embed", batch_char_embed.size()) 144 | concat = torch.cat((last_pos_embed, batch_char_embed), 1) 145 | z = self.dropout(F.tanh(self.combine_linear(concat))) 146 | h_now, c_now = self.lstmcell(z, (h, c)) 147 | 148 | return h_now, c_now 149 | 150 | def batch_wordLstm_2(self, id_char, batch_length, encoder_out, state): 151 | if id_char is 0: 152 | h, c, z = self.init_hidden_cell(batch_length) 153 | else: 154 | h, c = state.word_hiddens[-1], state.word_cells[-1] 155 | # copy with the pos features 156 | last_pos = Variable(torch.zeros(batch_length)).type(torch.LongTensor) 157 | if self.args.use_cuda is True: last_pos = last_pos.cuda() 158 | pos_id_array = np.array(state.pos_id[-1]) 159 | last_pos.data.copy_(torch.from_numpy(pos_id_array)) 160 | # print(last_pos) 161 | last_pos_embed = self.dropout(self.pos_embed(last_pos)) 162 | 163 | # copy with the word features 164 | batch_char_embed = [] 165 | for id_batch, id_batch_value in enumerate(state.words_startindex[-1]): 166 | chars_embed = [] 167 | last_word_len = 0 168 | if id_batch_value is -1: 169 | word_bucket = Variable(torch.zeros(1, 2 * self.args.rnn_hidden_dim)) 170 | if self.args.use_cuda is True: 171 | word_bucket = word_bucket.cuda() 172 | batch_char_embed.append(word_bucket) 173 | continue 174 | last_word_len = id_char - id_batch_value 175 | chars_embed.append(encoder_out.permute(1, 0, 2)[id_batch][id_batch_value:id_char].view(1, last_word_len, 2 * self.args.rnn_hidden_dim)) 176 | chars_embed = torch.cat(chars_embed, 1) 177 | last_word_embed = F.avg_pool1d(chars_embed.permute(0, 2, 1), last_word_len).view(1, self.args.rnn_hidden_dim * 2) 178 | batch_char_embed.append(last_word_embed) 179 | batch_char_embed = torch.cat(batch_char_embed, 0) 180 | concat = torch.cat((last_pos_embed, batch_char_embed), 1) 181 | z = self.dropout(F.tanh(self.combine_linear(concat))) 182 | h_now, c_now = self.lstmcell(z, (h, c)) 183 | 184 | return h_now, c_now 185 | 186 | def batch_wordLstm(self, id_char, batch_length, encoder_out, state): 187 | if id_char is 0: 188 | h, c, z = self.init_hidden_cell(batch_length) 189 | else: 190 | h, c = state.word_hiddens[-1], state.word_cells[-1] 191 | # copy with the pos features 192 | last_pos = Variable(torch.zeros(batch_length)).type(torch.LongTensor) 193 | if self.args.use_cuda is True: last_pos = last_pos.cuda() 194 | pos_id_array = np.array(state.pos_id[-1]) 195 | last_pos.data.copy_(torch.from_numpy(pos_id_array)) 196 | # print(last_pos) 197 | last_pos_embed = self.dropout(self.pos_embed(last_pos)) 198 | 199 | # copy with the word features 200 | batch_char_embed = [] 201 | for id_batch, id_batch_value in enumerate(state.words_startindex[-1]): 202 | chars_embed = [] 203 | last_word_len = 0 204 | if id_batch_value is -1: 205 | word_bucket = Variable(torch.zeros(1, 2 * self.args.rnn_hidden_dim)) 206 | if self.args.use_cuda is True: 207 | word_bucket = word_bucket.cuda() 208 | batch_char_embed.append(word_bucket) 209 | continue 210 | last_word_len = id_char - id_batch_value 211 | chars_embed.append((encoder_out.permute(1, 0, 2)[id_batch][id_batch_value:id_char].unsqueeze(0))) 212 | # chars_embed = torch.cat(list(encoder_out.permute(1, 0, 2)[id_batch][id_batch_value:id_char].view(1, last_word_len, 2 * self.args.rnn_hidden_dim)), 1) 213 | chars_embed = torch.cat(chars_embed, 1).permute(0, 2, 1) 214 | last_word_embed = F.avg_pool1d(chars_embed, chars_embed.size(2)).squeeze(2) 215 | batch_char_embed.append(last_word_embed) 216 | batch_char_embed = torch.cat(batch_char_embed, 0) 217 | concat = torch.cat((last_pos_embed, batch_char_embed), 1) 218 | z = self.dropout(F.tanh(self.combine_linear(concat))) 219 | h_now, c_now = self.lstmcell(z, (h, c)) 220 | 221 | return h_now, c_now 222 | 223 | def batch_action(self, state, index, output, hidden_now, cell_now, batch_length, train): 224 | action = [] 225 | if train: 226 | for i in range(batch_length): 227 | if index < len(state.gold[i]): 228 | action.append(state.gold[i][index]) 229 | else: 230 | action.append("ACT") 231 | else: 232 | for i in range(batch_length): 233 | actionID = self.getMaxindex_1(self.args, output[i].view(self.args.label_size)) 234 | action.append(self.args.create_alphabet.label_alphabet.from_id(actionID)) 235 | state.actions.append(action) 236 | 237 | pos_id = [] 238 | start_index = [] 239 | for id_batch, act in enumerate(action): 240 | pos = act.find("#") 241 | if pos == -1: 242 | # app 243 | if index < len(state.chars[id_batch]): 244 | state.words[id_batch][-1] += (state.chars[id_batch][index]) 245 | start_index.append((index + 1) - len(state.words[id_batch][-1])) 246 | else: 247 | start_index.append(-1) 248 | 249 | if act == app: 250 | pos_id.append(state.pos_id[-1][id_batch]) 251 | elif act == "ACT": 252 | pos_id.append(self.pos_paddingKey) 253 | else: 254 | posLabel = act[pos + 1:] 255 | if index < len(state.chars[id_batch]): 256 | temp_word = state.chars[id_batch][index] 257 | state.words[id_batch].append(temp_word) 258 | state.pos_labels[id_batch].append(posLabel) 259 | start_index.append((index + 1) - len(state.words[id_batch][-1])) 260 | else: 261 | start_index.append(-1) 262 | posId = self.args.create_alphabet.pos_alphabet.loadWord2idAndId2Word(posLabel) 263 | pos_id.append(posId) 264 | 265 | state.words_startindex.append(start_index) 266 | state.pos_id.append(pos_id) 267 | state.word_cells.append(cell_now) 268 | state.word_hiddens.append(hidden_now) 269 | 270 | def getMaxindex_1(self, args, decoder_output): 271 | # print("get max index ......") 272 | decoder_output_list = decoder_output.data.tolist() 273 | maxIndex = decoder_output_list.index(np.max(decoder_output_list)) 274 | return maxIndex 275 | 276 | def getMaxindex(self, args, decoder_output): 277 | max = decoder_output.data[0] 278 | maxIndex = 0 279 | for idx in range(1, args.label_size): 280 | if decoder_output.data[idx] > max: 281 | max = decoder_output.data[idx] 282 | maxIndex = idx 283 | return maxIndex 284 | 285 | 286 | 287 | 288 | 289 | -------------------------------------------------------------------------------- /models/encoder_wordlstm.py: -------------------------------------------------------------------------------- 1 | # coding=utf-8 2 | from loaddata.common import paddingkey 3 | import torch.nn 4 | import torch.nn as nn 5 | import torch.nn.functional as F 6 | from torch.autograd import Variable 7 | import torch.nn.init as init 8 | import numpy as np 9 | import random 10 | import hyperparams as hy 11 | torch.manual_seed(hy.seed_num) 12 | random.seed(hy.seed_num) 13 | 14 | """ 15 | sequence to sequence Encode model 16 | """ 17 | 18 | 19 | class Encoder_WordLstm(nn.Module): 20 | 21 | def __init__(self, args): 22 | print("Encoder model --- LSTM") 23 | super(Encoder_WordLstm, self).__init__() 24 | self.args = args 25 | 26 | # random 27 | self.char_embed = nn.Embedding(self.args.embed_char_num, self.args.embed_char_dim) 28 | for index in range(self.args.embed_char_dim): 29 | self.char_embed.weight.data[self.args.create_alphabet.char_PaddingID][index] = 0 30 | self.char_embed.weight.requires_grad = True 31 | 32 | self.bichar_embed = nn.Embedding(self.args.embed_bichar_num, self.args.embed_bichar_dim) 33 | for index in range(self.args.embed_bichar_dim): 34 | self.bichar_embed.weight.data[self.args.create_alphabet.bichar_PaddingID][index] = 0 35 | self.bichar_embed.weight.requires_grad = True 36 | 37 | # fix the word embedding 38 | self.static_char_embed = nn.Embedding(self.args.static_embed_char_num, self.args.embed_char_dim) 39 | init.uniform(self.static_char_embed.weight, a=-np.sqrt(3 / self.args.embed_char_dim), 40 | b=np.sqrt(3 / self.args.embed_char_dim)) 41 | self.static_bichar_embed = nn.Embedding(self.args.static_embed_bichar_num, self.args.embed_bichar_dim) 42 | init.uniform(self.static_bichar_embed.weight, a=-np.sqrt(3 / self.args.embed_bichar_dim), 43 | b=np.sqrt(3 / self.args.embed_bichar_dim)) 44 | 45 | # load external word embedding 46 | if args.char_Embedding is True: 47 | print("char_Embedding") 48 | pretrained_char_weight = np.array(args.pre_char_word_vecs) 49 | self.static_char_embed.weight.data.copy_(torch.from_numpy(pretrained_char_weight)) 50 | for index in range(self.args.embed_char_dim): 51 | self.static_char_embed.weight.data[self.args.create_static_alphabet.char_PaddingID][index] = 0 52 | self.static_char_embed.weight.requires_grad = False 53 | 54 | if args.bichar_Embedding is True: 55 | print("bichar_Embedding") 56 | pretrained_bichar_weight = np.array(args.pre_bichar_word_vecs) 57 | self.static_bichar_embed.weight.data.copy_(torch.from_numpy(pretrained_bichar_weight)) 58 | # print(self.static_bichar_embed.weight.data[self.args.create_static_alphabet.bichar_PaddingID]) 59 | # print(self.static_bichar_embed.weight.data[self.args.create_static_alphabet.bichar_UnkID]) 60 | for index in range(self.args.embed_bichar_dim): 61 | self.static_bichar_embed.weight.data[self.args.create_static_alphabet.bichar_PaddingID][index] = 0 62 | self.static_bichar_embed.weight.requires_grad = False 63 | 64 | self.lstm_left = nn.LSTM(input_size=self.args.hidden_size, hidden_size=self.args.rnn_hidden_dim, 65 | dropout=self.args.dropout_lstm, bias=True) 66 | self.lstm_right = nn.LSTM(input_size=self.args.hidden_size, hidden_size=self.args.rnn_hidden_dim, 67 | dropout=self.args.dropout_lstm, bias=True) 68 | 69 | # init lstm weight and bias 70 | init.xavier_uniform(self.lstm_left.weight_ih_l0) 71 | init.xavier_uniform(self.lstm_left.weight_hh_l0) 72 | init.xavier_uniform(self.lstm_right.weight_ih_l0) 73 | init.xavier_uniform(self.lstm_right.weight_hh_l0) 74 | value = np.sqrt(6 / (self.args.rnn_hidden_dim + 1)) 75 | self.lstm_left.bias_ih_l0.data.uniform_(-value, value) 76 | self.lstm_left.bias_hh_l0.data.uniform_(-value, value) 77 | self.lstm_right.bias_ih_l0.data.uniform_(-value, value) 78 | self.lstm_right.bias_hh_l0.data.uniform_(-value, value) 79 | 80 | self.hidden_l = self.init_hidden_cell(self.args.batch_size) 81 | self.hidden_r = self.init_hidden_cell(self.args.batch_size) 82 | 83 | self.dropout = nn.Dropout(self.args.dropout) 84 | self.dropout_embed = nn.Dropout(self.args.dropout_embed) 85 | 86 | self.input_dim = (self.args.embed_char_dim + self.args.embed_bichar_dim) * 2 87 | self.liner = nn.Linear(in_features=self.input_dim, out_features=self.args.hidden_size, bias=True) 88 | 89 | # init linear 90 | init.xavier_uniform(self.liner.weight) 91 | init_linear_value = np.sqrt(6 / (self.args.hidden_size + 1)) 92 | self.liner.bias.data.uniform_(-init_linear_value, init_linear_value) 93 | 94 | def init_hidden_cell(self, batch_size=1): 95 | # the first is the hidden h 96 | # the second is the cell c 97 | if self.args.use_cuda is True: 98 | return (Variable(torch.zeros(1, batch_size, self.args.rnn_hidden_dim)).cuda(), 99 | Variable(torch.zeros(1, batch_size, self.args.rnn_hidden_dim)).cuda()) 100 | else: 101 | return (Variable(torch.zeros(1, batch_size, self.args.rnn_hidden_dim)), 102 | Variable(torch.zeros(1, batch_size, self.args.rnn_hidden_dim))) 103 | 104 | def init_cell_hidden(self, batch=1): 105 | if self.args.use_cuda is True: 106 | return (torch.autograd.Variable(torch.zeros(batch, self.args.rnn_hidden_dim)).cuda(), 107 | torch.autograd.Variable(torch.zeros(batch, self.args.rnn_hidden_dim)).cuda()) 108 | else: 109 | return (torch.autograd.Variable(torch.zeros(batch, self.args.rnn_hidden_dim)), 110 | torch.autograd.Variable(torch.zeros(batch, self.args.rnn_hidden_dim))) 111 | 112 | def forward(self, features): 113 | batch_length = features.batch_length 114 | char_features_num = features.static_char_features.size(1) 115 | # fine tune 116 | char_features = self.char_embed(features.char_features) 117 | bichar_left_features = self.bichar_embed(features.bichar_left_features) 118 | bichar_right_features = self.bichar_embed(features.bichar_right_features) 119 | 120 | # fix the word embedding 121 | static_char_features = self.static_char_embed(features.static_char_features) 122 | static_bichar_l_features = self.static_bichar_embed(features.static_bichar_left_features) 123 | static_bichar_r_features = self.static_bichar_embed(features.static_bichar_right_features) 124 | 125 | # dropout 126 | char_features = self.dropout_embed(char_features) 127 | bichar_left_features = self.dropout_embed(bichar_left_features) 128 | bichar_right_features = self.dropout_embed(bichar_right_features) 129 | static_char_features = self.dropout_embed(static_char_features) 130 | static_bichar_l_features = self.dropout_embed(static_bichar_l_features) 131 | static_bichar_r_features = self.dropout_embed(static_bichar_r_features) 132 | 133 | # left concat 134 | left_concat = torch.cat((char_features, static_char_features, bichar_left_features, static_bichar_l_features), 2) 135 | # left_concat = left_concat.view(batch_length * char_features_num, self.input_dim) 136 | # right concat 137 | right_concat = torch.cat((char_features, static_char_features, bichar_right_features, static_bichar_r_features), 2) 138 | # right_concat = right_concat.view(batch_length * char_features_num, self.input_dim) 139 | 140 | # non-linear 141 | left_concat_non_linear = self.dropout(F.tanh(self.liner(left_concat))) 142 | # left_concat = left_concat.view(batch_length, char_features_num, self.args.rnn_hidden_dim) 143 | left_concat_input = left_concat_non_linear.permute(1, 0, 2) 144 | 145 | right_concat_non_linear = self.dropout(F.tanh(self.liner(right_concat))) 146 | right_concat_input = right_concat_non_linear.permute(1, 0, 2) 147 | # right_concat = right_concat.view(batch_length, char_features_num, self.args.rnn_hidden_dim) 148 | 149 | # reverse right_concat 150 | right_concat_input = right_concat_input.permute(1, 0, 2) 151 | for batch in range(batch_length): 152 | middle = right_concat_input.size(1) // 2 153 | # print(middle) 154 | for i, j in zip(range(0, middle, 1), range(right_concat_input.size(1) - 1, middle, -1)): 155 | temp = torch.zeros(right_concat_input[batch][i].data.size()) 156 | temp.copy_(right_concat_input[batch][i].data) 157 | right_concat_input[batch][i].data.copy_(right_concat_input[batch][j].data) 158 | right_concat_input[batch][j].data.copy_(temp) 159 | right_concat_input = right_concat_input.permute(1, 0, 2) 160 | 161 | # non-linear dropout 162 | left_concat_input = self.dropout(left_concat_input) 163 | right_concat_input = self.dropout(right_concat_input) 164 | 165 | # init hidden cell 166 | self.hidden = self.init_hidden_cell(batch_size=batch_length) 167 | 168 | # lstm 169 | # lstm_left_out, _ = self.lstm_left(left_concat_input, self.hidden) 170 | # lstm_right_out, _ = self.lstm_right(right_concat_input, self.hidden) 171 | lstm_left_out, _ = self.lstm_left(left_concat_input) 172 | lstm_right_out, _ = self.lstm_right(right_concat_input) 173 | 174 | # reverse lstm_right_out 175 | lstm_right_out = lstm_right_out.permute(1, 0, 2) 176 | for batch in range(batch_length): 177 | middle = lstm_right_out.size(1) // 2 178 | for i, j in zip(range(0, middle, 1), range(lstm_right_out.size(1) - 1, middle, -1)): 179 | temp = torch.zeros(lstm_right_out[batch][i].size()) 180 | temp.copy_(lstm_right_out[batch][i].data) 181 | lstm_right_out[batch][i].data.copy_(lstm_right_out[batch][j].data) 182 | lstm_right_out[batch][j].data.copy_(temp) 183 | lstm_right_out = lstm_right_out.permute(1, 0, 2) 184 | 185 | encoder_output = torch.cat((lstm_left_out, lstm_right_out), 2).permute(1, 0, 2) 186 | 187 | return encoder_output 188 | 189 | 190 | -------------------------------------------------------------------------------- /models/encoder_wordlstmcell.py: -------------------------------------------------------------------------------- 1 | # coding=utf-8 2 | from loaddata.common import paddingkey 3 | import torch.nn 4 | import torch.nn as nn 5 | import torch.nn.functional as F 6 | from torch.autograd import Variable 7 | import torch.nn.init as init 8 | import numpy as np 9 | import random 10 | import time 11 | import hyperparams as hy 12 | torch.manual_seed(hy.seed_num) 13 | random.seed(hy.seed_num) 14 | 15 | """ 16 | sequence to sequence Encode model 17 | """ 18 | 19 | 20 | class Encoder_WordLstm(nn.Module): 21 | 22 | def __init__(self, args): 23 | print("Encoder model --- LSTMCELL") 24 | super(Encoder_WordLstm, self).__init__() 25 | self.args = args 26 | 27 | # random 28 | self.char_embed = nn.Embedding(self.args.embed_char_num, self.args.embed_char_dim, sparse=False, 29 | padding_idx=self.args.create_alphabet.char_PaddingID) 30 | # for index in range(self.args.embed_char_dim): 31 | # self.char_embed.weight.data[self.args.create_alphabet.char_PaddingID][index] = 0 32 | self.char_embed.weight.requires_grad = True 33 | 34 | self.bichar_embed = nn.Embedding(self.args.embed_bichar_num, self.args.embed_bichar_dim, sparse=False, 35 | padding_idx=self.args.create_alphabet.bichar_PaddingID) 36 | # for index in range(self.args.embed_bichar_dim): 37 | # self.bichar_embed.weight.data[self.args.create_alphabet.bichar_PaddingID][index] = 0 38 | self.bichar_embed.weight.requires_grad = True 39 | 40 | # fix the word embedding 41 | self.static_char_embed = nn.Embedding(self.args.static_embed_char_num, self.args.embed_char_dim, sparse=False, 42 | padding_idx=self.args.create_static_alphabet.char_PaddingID) 43 | init.uniform(self.static_char_embed.weight, a=-np.sqrt(3 / self.args.embed_char_dim), 44 | b=np.sqrt(3 / self.args.embed_char_dim)) 45 | self.static_bichar_embed = nn.Embedding(self.args.static_embed_bichar_num, self.args.embed_bichar_dim, 46 | sparse=False, 47 | padding_idx=self.args.create_static_alphabet.bichar_PaddingID) 48 | init.uniform(self.static_bichar_embed.weight, a=-np.sqrt(3 / self.args.embed_bichar_dim), 49 | b=np.sqrt(3 / self.args.embed_bichar_dim)) 50 | 51 | # load external word embedding 52 | if args.char_Embedding is True: 53 | print("char_Embedding") 54 | pretrained_char_weight = np.array(args.pre_char_word_vecs) 55 | self.static_char_embed.weight.data.copy_(torch.from_numpy(pretrained_char_weight)) 56 | for index in range(self.args.embed_char_dim): 57 | self.static_char_embed.weight.data[self.args.create_static_alphabet.char_PaddingID][index] = 0 58 | self.static_char_embed.weight.requires_grad = False 59 | 60 | if args.bichar_Embedding is True: 61 | print("bichar_Embedding") 62 | pretrained_bichar_weight = np.array(args.pre_bichar_word_vecs) 63 | self.static_bichar_embed.weight.data.copy_(torch.from_numpy(pretrained_bichar_weight)) 64 | # print(self.static_bichar_embed.weight.data[self.args.create_static_alphabet.bichar_PaddingID]) 65 | # print(self.static_bichar_embed.weight.data[self.args.create_static_alphabet.bichar_UnkID]) 66 | for index in range(self.args.embed_bichar_dim): 67 | self.static_bichar_embed.weight.data[self.args.create_static_alphabet.bichar_PaddingID][index] = 0 68 | self.static_bichar_embed.weight.requires_grad = False 69 | 70 | self.lstm_left = nn.LSTMCell(input_size=self.args.hidden_size, hidden_size=self.args.rnn_hidden_dim, bias=True) 71 | self.lstm_right = nn.LSTMCell(input_size=self.args.hidden_size, hidden_size=self.args.rnn_hidden_dim, bias=True) 72 | 73 | # init lstm weight and bias 74 | init.xavier_uniform(self.lstm_left.weight_ih) 75 | init.xavier_uniform(self.lstm_left.weight_hh) 76 | init.xavier_uniform(self.lstm_right.weight_ih) 77 | init.xavier_uniform(self.lstm_right.weight_hh) 78 | value = np.sqrt(6 / (self.args.rnn_hidden_dim + 1)) 79 | self.lstm_left.bias_hh.data.uniform_(-value, value) 80 | self.lstm_left.bias_ih.data.uniform_(-value, value) 81 | self.lstm_right.bias_hh.data.uniform_(-value, value) 82 | self.lstm_right.bias_ih.data.uniform_(-value, value) 83 | 84 | self.hidden_l = self.init_hidden_cell(self.args.batch_size) 85 | self.hidden_r = self.init_hidden_cell(self.args.batch_size) 86 | 87 | self.dropout = nn.Dropout(self.args.dropout) 88 | self.dropout_embed = nn.Dropout(self.args.dropout_embed) 89 | 90 | self.input_dim = (self.args.embed_char_dim + self.args.embed_bichar_dim) * 2 91 | if self.args.use_cuda is True: 92 | self.liner = nn.Linear(in_features=self.input_dim, out_features=self.args.hidden_size, bias=True).cuda() 93 | else: 94 | self.liner = nn.Linear(in_features=self.input_dim, out_features=self.args.hidden_size, bias=True) 95 | 96 | # init linear 97 | init.xavier_uniform(self.liner.weight) 98 | init_linear_value = np.sqrt(6 / (self.args.hidden_size + 1)) 99 | self.liner.bias.data.uniform_(-init_linear_value, init_linear_value) 100 | 101 | def init_hidden_cell(self, batch_size=1): 102 | # the first is the hidden h 103 | # the second is the cell c 104 | if self.args.use_cuda is True: 105 | return (Variable(torch.zeros(batch_size, self.args.rnn_hidden_dim)).cuda(), 106 | Variable(torch.zeros(batch_size, self.args.rnn_hidden_dim)).cuda()) 107 | else: 108 | return (Variable(torch.zeros(batch_size, self.args.rnn_hidden_dim)), 109 | Variable(torch.zeros(batch_size, self.args.rnn_hidden_dim))) 110 | 111 | def init_cell_hidden(self, batch=1): 112 | if self.args.use_cuda is True: 113 | return (torch.autograd.Variable(torch.zeros(batch, self.args.rnn_hidden_dim)).cuda(), 114 | torch.autograd.Variable(torch.zeros(batch, self.args.rnn_hidden_dim)).cuda()) 115 | else: 116 | return (torch.autograd.Variable(torch.zeros(batch, self.args.rnn_hidden_dim)), 117 | torch.autograd.Variable(torch.zeros(batch, self.args.rnn_hidden_dim))) 118 | 119 | # @time 120 | def forward(self, features): 121 | batch_length = features.batch_length 122 | char_features_num = features.static_char_features.size(1) 123 | 124 | char_features = self.char_embed(features.char_features) 125 | bichar_left_features = self.bichar_embed(features.bichar_left_features) 126 | bichar_right_features = self.bichar_embed(features.bichar_right_features) 127 | 128 | # fix the word embedding 129 | static_char_features = self.static_char_embed(features.static_char_features) 130 | static_bichar_l_features = self.static_bichar_embed(features.static_bichar_left_features) 131 | static_bichar_r_features = self.static_bichar_embed(features.static_bichar_right_features) 132 | 133 | # dropout 134 | char_features = self.dropout_embed(char_features) 135 | bichar_left_features = self.dropout_embed(bichar_left_features) 136 | bichar_right_features = self.dropout_embed(bichar_right_features) 137 | static_char_features = self.dropout_embed(static_char_features) 138 | static_bichar_l_features = self.dropout_embed(static_bichar_l_features) 139 | static_bichar_r_features = self.dropout_embed(static_bichar_r_features) 140 | 141 | # left concat 142 | left_concat = torch.cat((char_features, static_char_features, bichar_left_features, static_bichar_l_features), 2) 143 | # right concat 144 | right_concat = torch.cat((char_features, static_char_features, bichar_right_features, static_bichar_r_features), 2) 145 | 146 | # non-linear 147 | left_concat_non_linear = self.dropout(F.tanh(self.liner(left_concat))) 148 | left_concat_input = left_concat_non_linear.permute(1, 0, 2) 149 | 150 | right_concat_non_linear = self.dropout(F.tanh(self.liner(right_concat))) 151 | right_concat_input = right_concat_non_linear.permute(1, 0, 2) 152 | 153 | # # init hidden cell 154 | # self.hidden = self.init_hidden_cell(batch_size=batch_length) 155 | # left_lstm_output, _ = self.lstm_left(left_concat_input) 156 | 157 | left_h, left_c = self.init_cell_hidden(batch_length) 158 | right_h, right_c = self.init_cell_hidden(batch_length) 159 | left_lstm_output = [] 160 | right_lstm_output = [] 161 | for idx, id_right in zip(range(char_features_num), reversed(range(char_features_num))): 162 | left_h, left_c = self.lstm_left(left_concat_input[idx], (left_h, left_c)) 163 | right_h, right_c = self.lstm_right(right_concat_input[id_right], (right_h, right_c)) 164 | left_h = self.dropout(left_h) 165 | right_h = self.dropout(right_h) 166 | left_lstm_output.append(left_h.view(batch_length, 1, self.args.rnn_hidden_dim)) 167 | right_lstm_output.insert(0, right_h.view(batch_length, 1, self.args.rnn_hidden_dim)) 168 | left_lstm_output = torch.cat(left_lstm_output, 1) 169 | right_lstm_output = torch.cat(right_lstm_output, 1) 170 | 171 | encoder_output = torch.cat((left_lstm_output, right_lstm_output), 2) 172 | 173 | return encoder_output 174 | 175 | 176 | -------------------------------------------------------------------------------- /pytorch.py: -------------------------------------------------------------------------------- 1 | # line = "0 simplistic , silly and tedious ." 2 | # label, sep, text = line.partition(' ') 3 | # print(label) 4 | # print(sep) 5 | # print(text) 6 | 7 | 8 | 9 | # from torch.autograd import Variable 10 | # import torch 11 | # a = torch.zeros(18) 12 | # a = Variable(a) 13 | # print(a) 14 | # c = 0 15 | # print(a.numel()) 16 | # c += a.numel() 17 | # print(c) 18 | # b = torch.randn(1,2,3,4,5) 19 | # print(b) 20 | # print(b.numel()) 21 | 22 | 23 | 24 | 25 | # def cal_mean(list): 26 | # sum = 0.0 27 | # for i in list: 28 | # print(i) 29 | # sum += i 30 | # avg = (sum / len(list)) 31 | # return avg 32 | # 33 | # list = [10.9, 9.9, 8.8] 34 | # mean = cal_mean(list) 35 | # print(mean) 36 | 37 | 38 | 39 | 40 | # import torch 41 | # a = torch.FloatTensor([[1, 2], [3, 4]]) 42 | # b = torch.FloatTensor([[1, 2], [3, 4]]) 43 | # print(a) 44 | # print(b) 45 | # c = torch.mm(a, b) 46 | # print(c) 47 | # d = a.mm(b) 48 | # print(d) 49 | 50 | 51 | 52 | 53 | # from torch.autograd import Function, Variable 54 | # import torch 55 | # class sru_com(Function): 56 | # def __init__(self,b): 57 | # print("init") 58 | # 59 | # def forward(self,c): 60 | # print("forward") 61 | # return None 62 | # 63 | # x = sru_com(Variable(torch.randn(3,4)))(Variable(torch.randn(3,3))) 64 | 65 | 66 | # list = [1, 2, 3, 4, 5, 6] 67 | # print(list[-2::-1]) 68 | # print(list[-2::-2]) 69 | # print(list[-1::-1]) 70 | 71 | # import time 72 | # start = time.time() 73 | # for i in range(1000000): 74 | # print(i * 2) 75 | # print(i * 3 * 8 / 5 - 4) 76 | # end = time.time() 77 | # print("Times: ", end - start) 78 | 79 | import torch 80 | import numpy as np 81 | # a = [2.0, 5, 2.0, 2] 82 | # b = [1.5, 0.1, 1, 1] 83 | # c = np.subtract(a, b) 84 | # print(c) 85 | # print(c[0]) 86 | 87 | # a = np.random.rand(240000,5) 88 | # print(a) 89 | 90 | # a = np.sqrt(0) 91 | # print(a) 92 | 93 | # a = torch.rand(3, 4, 5) 94 | # print(a) 95 | # print(a.reverse()) 96 | # print(a[0][0]) 97 | # list = (a[0][0]).tolist() 98 | # b = list.reverse() 99 | # print(list) 100 | # print(list.reverse()) 101 | # b = reversed(list) 102 | # print(b) 103 | # b = torch.inverse(a) 104 | # print(b) 105 | 106 | 107 | 108 | # a = 1 % -1 == 0 109 | # print(a) 110 | # 111 | # b = 4 % -1 == 0 112 | # print(b) 113 | 114 | 115 | a = [[1, 2, 3], [1, 2, 4]] 116 | print(a) 117 | b = torch.LongTensor(a) 118 | print(b) -------------------------------------------------------------------------------- /run.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | export OMP_NUM_THREADS=1 3 | export CUDA_VISIBLE_DEVICES=0 4 | # python -u main_hyperparams.py > log/log_1125_myself_lstm 2>&1 & 5 | python -u main_hyperparams.py > log_1126_myself_speedtest_1.txt 6 | 7 | -------------------------------------------------------------------------------- /state.py: -------------------------------------------------------------------------------- 1 | 2 | class state_instance: 3 | def __init__(self, inst): 4 | self.chars = inst.chars 5 | self.gold = inst.gold 6 | self.words = [] 7 | self.pos_id = [] 8 | self.pos_labels = [] 9 | self.actions = [] 10 | 11 | self.word_hiddens = [] 12 | self.word_cells = [] 13 | 14 | self.all_h = [] 15 | self.all_c = [] 16 | 17 | 18 | class state_batch_instance: 19 | def __init__(self, features, char_features_num): 20 | self.chars = [] 21 | self.gold = [] 22 | self.words = [] 23 | self.words_startindex = [] 24 | self.pos_id = [] 25 | self.pos_labels = [] 26 | self.actions = [] 27 | 28 | self.word_hiddens = [] 29 | self.word_cells = [] 30 | 31 | self.all_h = [] 32 | self.all_c = [] 33 | for index in range(features.batch_length): 34 | self.chars.append(features.inst[index].chars) 35 | self.gold.append(features.inst[index].gold) 36 | 37 | self.words.append([]) 38 | self.pos_labels.append([]) 39 | 40 | def show(self): 41 | print("chars", self.chars) 42 | print("gold", self.gold) 43 | print("words", self.words) 44 | print("pos_id", self.pos_id) 45 | print("pos_labels", self.pos_labels) 46 | print("actions", self.actions) 47 | print("word_hidden", self.word_hiddens) 48 | print("word_cells", self.word_cells) 49 | print("all_h", self.all_h) 50 | print("all_c", self.all_c) 51 | 52 | 53 | -------------------------------------------------------------------------------- /temp_data.txt: -------------------------------------------------------------------------------- 1 | （ 新华社 北京 12月 31日 电 ） 2 | 最后 ， 我 从 北京 祝 大家 新年 快乐 ！ 3 | 女士 们 ， 先生 们 ， 同志 们 ， 朋友 们 ： 4 | 共同 创造 美好 的 新 世纪 —— 二○○一年 新年 贺词 5 | （ 二○○○年 十二月 三十一日 ） （ 附 图片 1 张 ） 6 | 中共中央 总书记 、 国家 主席 、 中央军委 主席 江 泽民 发表 新年 贺词 。 7 | 2001年 1月 1日 零时 ， 随着 新 世纪 钟声 的 响起 ， 北京 中华 世纪坛 礼花 齐 放 ， 万民 欢腾 。 （ 本报 记者 徐 烨 摄 ） 2001年 新年 钟声 即将 敲响 。 人类 社会 前进 的 航船 就要 驶入 21 世纪 的 新 航程 。 中国 人民 进入 了 向 现代化 建设 第三 步 战略 目标 迈进 的 新 征程 。 8 | 我 相信 ， 只要 全世界 人民 以及 所有 关心 人类 前途 和 命运 的 政治家 们 共同 努力 ， 携手 前进 ， 我们 居住 的 这个 星球 一定 能够 成为 各国 人民 共享 和平 、 共同 发展 和 共同 进步 的 美好 世界 ！ 9 | 面对 新 世纪 ， 世界 各国 人民 的 共同 愿望 是 ： 继续 发展 人类 以往 创造 的 一切 文明 成果 ， 克服 20 世纪 困扰 着 人类 的 战争 和 贫困 问题 ， 推进 和平 与 发展 的 崇高 事业 ， 创造 一个 美好 的 世界 。 10 | 在 这个 激动人心 的 时刻 ， 我 很 高兴 通过 中国 国际 广播 电台 、 中央 人民 广播 电台 和 中央 电视台 ， 向 全国 各族 人民 ， 向 香港 特别 行政区 同胞 、 澳门 特别 行政区 同胞 和 台湾 同胞 、 海外 侨胞 ， 向 世界 各国 的 朋友 们 ， 致以 新 世纪 第一 个 新年 的 祝贺 ！ 11 | 中国 人民 进入 新 世纪 的 主要 任务 ， 就 是 继续 推进 现代化 建设 ， 完成 祖国 统一 ， 维护 世界 和平 与 促进 共同 发展 。 中国 人民 将 坚持 以 邓小平理论 为 指导 ， 坚定不移 地 推进 改革 开放 和 经济 建设 ， 坚定不移 地 贯彻 “ 和平 统一 、 一国两制 ” 方针 ， 坚定不移 地 奉行 独立自主 的 和平 外交 政策 ， 为 不断 推进 建设 有 中国 特色 社会主义 事业 ， 最终 实现 祖国 的 完全 统一 ， 实现 中华民族 的 伟大 复兴 而 不懈 奋斗 ， 争取 对 人类 作出 新 的 更 大 的 贡献 。 12 | 过去 的 一 年 ， 是 我国 社会主义 改革 开放 和 现代化 建设 进程 中 具有 标志 意义 的 一 年 。 在 中国 共产党 的 领导 下 ， 全国 各族 人民 团结 奋斗 ， 国民经济 继续 保持 较 快 的 发展 势头 ， 经济 结构 的 战略性 调整 顺利 部署 实施 。 西部 大 开发 取得 良好 开端 。 精神文明 建设 和 民主 法制 建设 进一步 加强 。 我们 在 过去 几 年 取得 成绩 的 基础 上 ， 胜利 完成 了 第九 个 五年计划 。 我国 已 进入 了 全面 建设 小康 社会 ， 加快 社会主义 现代化 建设 的 新 的 发展 阶段 。 13 | 我们 希望 ， 新 世纪 成为 各种 文明 共同 进步 的 世纪 。 世界 是 丰富多彩 的 。 世界 各国 的 文明 ， 都 是 人类 的 宝贵 财富 ， 应该 相互 尊重 、 相互 学习 。 历史 充分 证明 ， 各国 人民 自主 选择 各自 的 社会制度 和 发展 道路 ， 在 继承 和 发展 本 民族 文明 的 基础 上 吸取 其他 文明 的 精华 ， 按照 自己 的 意志 创造 并 享受 美好 的 生活 ， 是 世界 发展 的 重要 动力 。 只有 加强 各种 文明 之间 的 交流 ， 推动 各种 文明 共同 进步 ， 世界 和平 与 发展 的 崇高 事业 才 能 真正 实现 。 14 | 我们 希望 ， 新 世纪 成为 各国 人民 共享 和平 的 世纪 。 在 20 世纪 里 ， 世界 饱受 各种 战争 和 冲突 的 苦难 。 时至今日 ， 仍 有 不少 国家 和 地区 的 人民 还 在 忍受 战火 的 煎熬 。 中国 人民 真诚 地 祝愿 他们 早日 过 上 和平 安定 的 生活 。 中国 人民 热爱 和平 与 自由 ， 始终 奉行 独立自主 的 和平 外交 政策 ， 永远 站 在 人类 正义 事业 的 一边 。 我们 愿 同 世界 上 一切 爱好 和平 的 国家 和 人民 一道 ， 为 促进 世界 多极化 ， 建立 和平 稳定 、 公正 合理 的 国际 政治 经济 新 秩序 而 努力 奋斗 。 15 | 我们 希望 ， 新 世纪 成为 各国 人民 共同 发展 的 世纪 。 在 20 世纪 里 ， 世界 的 生产力 和 科学技术 取得 了 惊人 的 成就 。 但是 ， 世界 上 仍 有 许多 人民 尚未 摆脱 贫穷 和 饥饿 ， 有的 甚至 连 基本 生存 条件 都 不 具备 ， 时刻 面临 着 死亡 的 威胁 。 经济 全球化 对 生产力 发展 的 新 推动 ， 科学技术 突飞猛进 带来 的 新 成果 ， 应该 造福 于 全人类 ， 特别 是 应该 用 来 促进 发展中国家 的 发展 ， 改善 极度 贫困 人口 的 生活 境遇 ， 使 他们 得以 具备 自我 发展 的 条件 。 中国 人民 将 坚持不懈 地 为此 作出 自己 的 贡献 。 16 | -------------------------------------------------------------------------------- /train_seq2seq_wordlstm_batch.py: -------------------------------------------------------------------------------- 1 | import os 2 | import sys 3 | import torch 4 | import torch.autograd as autograd 5 | import torch.nn.functional as F 6 | import torch.nn.utils as utils 7 | import torch.optim.lr_scheduler as lr_scheduler 8 | import random 9 | import hyperparams as hy 10 | from eval import Eval 11 | import time 12 | torch.manual_seed(hy.seed_num) 13 | random.seed(hy.seed_num) 14 | 15 | """ 16 | train function 17 | """ 18 | 19 | 20 | def train(train_iter, dev_iter, test_iter, model_encoder, model_decoder, args): 21 | 22 | if args.Adam is True: 23 | print("Adam Training......") 24 | model_encoder_parameters = filter(lambda p: p.requires_grad, model_encoder.parameters()) 25 | model_decoder_parameters = filter(lambda p: p.requires_grad, model_decoder.parameters()) 26 | optimizer_encoder = torch.optim.Adam(params=filter(lambda p: p.requires_grad, model_encoder.parameters()), 27 | lr=args.lr, 28 | weight_decay=args.init_weight_decay) 29 | optimizer_decoder = torch.optim.Adam(params=filter(lambda p: p.requires_grad, model_decoder.parameters()), 30 | lr=args.lr, 31 | weight_decay=args.init_weight_decay) 32 | # optimizer_encoder = torch.optim.Adam(model_encoder.parameters(), lr=args.lr, weight_decay=args.init_weight_decay) 33 | # optimizer_decoder = torch.optim.Adam(model_decoder.parameters(), lr=args.lr, weight_decay=args.init_weight_decay) 34 | 35 | steps = 0 36 | model_count = 0 37 | # for dropout in train / dev / test 38 | model_encoder.train() 39 | model_decoder.train() 40 | time_list = [] 41 | train_eval = Eval() 42 | dev_eval_seg = Eval() 43 | dev_eval_pos = Eval() 44 | test_eval_seg = Eval() 45 | test_eval_pos = Eval() 46 | for epoch in range(1, args.epochs+1): 47 | print("\n## 第{} 轮迭代，共计迭代 {} 次 ！##\n".format(epoch, args.epochs)) 48 | print("optimizer_encoder now lr is {}".format(optimizer_encoder.param_groups[0].get("lr"))) 49 | print("optimizer_decoder now lr is {} \n".format(optimizer_decoder.param_groups[0].get("lr"))) 50 | 51 | # train time 52 | start_time = time.time() 53 | 54 | # shuffle 55 | random.shuffle(train_iter) 56 | # random.shuffle(dev_iter) 57 | # random.shuffle(test_iter) 58 | 59 | model_encoder.train() 60 | model_decoder.train() 61 | 62 | for batch_count, batch_features in enumerate(train_iter): 63 | 64 | model_encoder.zero_grad() 65 | model_decoder.zero_grad() 66 | 67 | maxCharSize = batch_features.char_features.size()[1] 68 | encoder_out = model_encoder(batch_features) 69 | decoder_out, state = model_decoder(batch_features, encoder_out, train=True) 70 | 71 | cal_train_acc(batch_features, train_eval, batch_count, decoder_out, maxCharSize, args) 72 | 73 | loss = torch.nn.functional.nll_loss(decoder_out, batch_features.gold_features) 74 | # loss = F.cross_entropy(decoder_out, batch_features.gold_features) 75 | 76 | loss.backward() 77 | 78 | if args.init_clip_max_norm is not None: 79 | utils.clip_grad_norm(model_encoder_parameters, max_norm=args.init_clip_max_norm) 80 | utils.clip_grad_norm(model_decoder_parameters, max_norm=args.init_clip_max_norm) 81 | 82 | optimizer_encoder.step() 83 | optimizer_decoder.step() 84 | 85 | steps += 1 86 | if steps % args.log_interval == 0: 87 | sys.stdout.write("\rbatch_count = [{}] , loss is {:.6f} , (correct/ total_num) = acc ({} / {}) = " 88 | "{:.6f}%".format(batch_count + 1, loss.data[0], train_eval.correct_num, 89 | train_eval.gold_num, train_eval.acc() * 100)) 90 | # if steps % args.dev_interval == 0: 91 | # print("\ndev F-score") 92 | # dev_eval_pos.clear() 93 | # dev_eval_seg.clear() 94 | # eval(dev_iter, model_encoder, model_decoder, args, dev_eval_seg, dev_eval_pos) 95 | # # model_encoder.train() 96 | # # model_decoder.train() 97 | # if steps % args.test_interval == 0: 98 | # print("test F-score") 99 | # test_eval_pos.clear() 100 | # test_eval_seg.clear() 101 | # eval(test_iter, model_encoder, model_decoder, args, test_eval_seg, test_eval_pos) 102 | # print("\n") 103 | # train time 104 | end_time = time.time() 105 | print("\ntrain time cost: ", end_time - start_time, 's') 106 | time_list.append(end_time - start_time) 107 | if time_list is not None: 108 | avg_time = sum(time_list) / len(time_list) 109 | print("{} - {} epoch avg time {}".format(1, epoch, avg_time)) 110 | model_encoder.eval() 111 | model_decoder.eval() 112 | if steps is not 0: 113 | print("\n{} epoch dev F-score".format(epoch)) 114 | dev_eval_pos.clear() 115 | dev_eval_seg.clear() 116 | eval(dev_iter, model_encoder, model_decoder, dev_eval_seg) 117 | # model_encoder.train() 118 | # model_decoder.train() 119 | if steps is not 0: 120 | print("{} epoch test F-score".format(epoch)) 121 | test_eval_pos.clear() 122 | test_eval_seg.clear() 123 | eval(test_iter, model_encoder, model_decoder, test_eval_seg) 124 | print("\n") 125 | 126 | 127 | def cal_train_acc(batch_features, train_eval, batch_count, decoder_out, maxCharSize, args): 128 | # print("calculate the acc of train ......") 129 | train_eval.clear() 130 | for id_batch in range(batch_features.batch_length): 131 | inst = batch_features.inst[id_batch] 132 | for id_char in range(inst.chars_size): 133 | actionID = getMaxindex(decoder_out[id_batch * maxCharSize + id_char], args) 134 | if actionID == inst.gold_index[id_char]: 135 | train_eval.correct_num += 1 136 | train_eval.gold_num += inst.chars_size 137 | 138 | 139 | def jointPRF_Batch(inst, state_words, seg_eval): 140 | words = state_words 141 | count = 0 142 | predict_seg = [] 143 | 144 | for idx in range(len(words)): 145 | w = words[idx] 146 | predict_seg.append('[' + str(count) + ',' + str(count + len(w)) + ']') 147 | count += len(w) 148 | 149 | seg_eval.gold_num += len(inst.gold_seg) 150 | seg_eval.predict_num += len(predict_seg) 151 | for p in predict_seg: 152 | if p in inst.gold_seg: 153 | seg_eval.correct_num += 1 154 | 155 | 156 | def getMaxindex(decode_out_acc, args): 157 | # print("get max index ......") 158 | max = decode_out_acc.data[0] 159 | maxIndex = 0 160 | for idx in range(1, args.label_size): 161 | if decode_out_acc.data[idx] > max: 162 | max = decode_out_acc.data[idx] 163 | maxIndex = idx 164 | return maxIndex 165 | 166 | 167 | def eval(data_iter, model_encoder, model_decoder, eval_seg): 168 | # eval time 169 | eval_start = time.time() 170 | for batch_features in data_iter: 171 | encoder_out = model_encoder(batch_features) 172 | decoder_out, state = model_decoder(batch_features, encoder_out, train=False) 173 | for i in range(batch_features.batch_length): 174 | jointPRF_Batch(batch_features.inst[i], state.words[i], eval_seg) 175 | 176 | # calculate the time 177 | print("eval time cost: ", time.time() - eval_start, 's') 178 | 179 | # calculate the F-Score 180 | p, r, f = eval_seg.getFscore() 181 | print("seg: precision = {}% recall = {}% , f-score = {}%\n".format(p, r, f)) 182 | 183 | 184 | 185 | 186 | -------------------------------------------------------------------------------- /word_embedding/README.md: -------------------------------------------------------------------------------- 1 | # pytorch_Chinese_word_segmentation 2 | Chinese word segmentation with the neural seq2seq model implement in pytorch 3 | --------------------------------------------------------------------------------