Upload 19 files

code/codekey_proofread.txt

@@ -0,0 +1,449 @@
+00101,危害国家安全罪
+00102,危害公共安全罪
+0010102,分裂国家罪
+0010103,煽动分裂国家罪
+0010105,颠覆国家政权罪
+0010106,煽动颠覆国家政权罪
+0010108,投敌叛变罪
+0010110,间谍罪
+0010111,为境外窃取、剌探、收买、非法提供国家秘密、情报罪
+0010201,放火罪
+0010202,决水罪
+0010203,爆炸罪
+0010204,投放危险物质罪
+0010205,以危险方法危害公共安全罪
+0010206,失火罪
+0010207,过失决水罪
+0010208,过失爆炸罪
+0010209,过失投放危险物质罪
+0010210,过失以危险方法危害公共安全罪
+0010211,破坏交通工具罪
+0010212,破坏交通设施罪
+0010213,破坏电力设备罪
+0010214,破坏易燃易爆设备罪
+0010216,过失损坏交通设施罪
+0010217,过失损坏电力设备罪
+0010218,过失损坏易燃易爆设备罪
+0010219,组织、领导、参加恐怖组织罪
+0010220,资助恐怖活动罪
+0010221,劫持航空器罪
+0010222,劫持船只、汽车罪
+0010223,暴力危及飞行安全罪
+0010224,破坏广播电视设施、公用电信设施罪
+0010225,过失损坏广播电视设施、公用电信设施罪
+0010226,非法制造、买卖、运输、邮寄、储存枪支、弹药、爆炸物罪
+0010227,非法制造、买卖、运输、储存危险物质罪
+0010228,违规制造、销售枪支罪
+0010229,盗窃、抢夺枪支、弹药、爆炸物、危险物质罪
+0010230,抢劫枪支、弹药、爆炸物、危险物质罪
+0010231,非法持有、私藏枪支、弹药罪
+0010232,非法出租、出借枪支罪
+0010234,非法携带枪支、弹药、管制刀具、危险物品危及公共安全罪
+0010235,重大飞行事故罪
+0010236,铁路运营安全事故罪
+0010237,交通肇事罪
+0010238,重大责任事故罪
+0010239,重大劳动安全事故罪
+0010240,危险物品肇事罪
+0010241,工程重大安全事故罪
+0010242,教育设施重大安全事故罪
+0010243,消防责任事故罪
+0010247,强令违章冒险作业罪
+0010248,大型群众性活动重大安全事故罪
+0010249,不报、谎报安全事故罪
+0010250,危险驾驶罪
+0010251,帮助恐怖活动罪
+0010253,宣扬恐怖主义、极端主义、煽动实施恐怖活动罪
+0010256,非法持有宣扬恐怖主义、极端主义物品罪
+0010301,生产、销售伪劣商品罪
+0010302,走私罪
+0010303,妨害对公司、企业的管理秩序罪
+0010304,破坏金融管理秩序罪
+0010305,金融诈骗罪
+0010306,危害税收征管罪
+0010307,侵犯知识产权罪
+0010308,扰乱市场秩序罪
+0010401,故意杀人罪
+0010402,过失致人死亡罪
+0010403,故意伤害罪
+0010404,过失致人重伤罪
+0010405,强奸罪
+0010406,强制猥亵、侮辱妇女罪
+0010407,猥亵儿童罪
+0010408,非法拘禁罪
+0010409,绑架罪
+0010410,拐卖妇女、儿童罪
+0010411,收买被拐卖的妇女、儿童罪
+0010413,诬告陷害罪
+0010415,雇用童工从事危重劳动罪
+0010416,非法搜查罪
+0010417,非法侵入住宅罪
+0010418,侮辱罪
+0010419,诽谤罪
+0010420,刑讯逼供罪
+0010421,暴力取证罪
+0010422,虐待被监管人罪
+0010423,煽动民族仇恨、民族歧视罪
+0010424,出版歧视、侮辱少数民族作品罪
+0010427,侵犯通信自由罪
+0010428,私自开拆、隐匿、毁弃邮件、电报罪
+0010429,报复陷害罪
+0010431,破坏选举罪
+0010432,暴力干涉婚姻自由罪
+0010433,重婚罪
+0010434,破坏军婚罪
+0010435,虐待罪
+0010436,遗弃罪
+0010437,拐骗儿童罪
+0010438,中介组织人员提供虚假证明文件罪
+0010439,中介组织人员出具证明文件重大失实罪
+0010440,奸淫幼女罪
+0010441,组织残疾人、儿童乞讨罪
+0010442,出售、非法提供公民个人信息罪
+0010443,非法获取公民个人信息罪
+0010444,组织未成年人进行违反治安管理活动罪
+0010445,组织出卖人体器官罪
+0010446,强迫劳动罪
+0010447,强制猥亵、侮辱罪
+0010448,侵犯公民个人信息罪
+0010449,虐待被监护、看护人罪
+0010501,抢劫罪
+0010502,盗窃罪
+0010503,诈骗罪
+0010504,抢夺罪
+0010505,聚众哄抢罪
+0010506,侵占罪
+0010507,职务侵占罪
+0010508,挪用资金罪
+0010509,挪用特定款物罪
+0010510,敲诈勒索罪
+0010511,故意毁坏财物罪
+0010512,破坏生产经营罪
+0010513,拒不支付劳动报酬罪
+0010601,扰乱公共秩序罪
+0010602,妨害司法罪
+0010603,妨害国（边）境管理罪
+0010604,妨害文物管理罪
+0010605,危害公共卫生罪
+0010606,破坏环境资源保护罪
+0010607,走私、贩卖、运输、制造毒品罪
+0010608,组织、强迫、引诱、容留、介绍卖淫罪
+0010609,制作、贩卖、传播淫秽物品罪
+0010701,阻碍军人执行职务罪
+0010702,阻碍军事行动罪
+0010703,破坏武器装备、军事设施、军事通信罪
+0010707,聚众扰乱军事管理区秩序罪
+0010708,冒充军人招摇撞骗罪
+0010711,接送不合格兵员罪
+0010712,伪造、变造、买卖武��部队公文、证件、印章罪
+0010714,非法生产、买卖军用标志罪
+0010722,过失损坏武器装备、军事设施、军事通信罪
+0010723,非法生产、买卖武装部队制式服装罪
+0010724,伪造、盗窃、买卖、非法提供、非法使用武装部队专用标志罪
+0010801,贪污罪
+0010802,挪用公款罪
+0010803,受贿罪
+0010804,单位受贿罪
+0010805,行贿罪
+0010806,对单位行贿罪
+0010807,介绍贿赂罪
+0010808,单位行贿罪
+0010809,巨额财产来源不明罪
+0010810,隐瞒境外存款罪
+0010811,私分国有资产罪
+0010812,私分罚没财物罪
+0010813,利用影响力受贿罪
+0010814,对有影响力的人行贿罪
+0010901,滥用职权罪
+0010902,玩忽职守罪
+0010903,故意泄露国家秘密罪
+0010904,过失泄露国家秘密罪
+0010905,徇私枉法罪
+0010906,民事、行政枉法裁判罪
+0010907,执行判决、裁定失职罪
+0010908,执行判决、裁定滥用职权罪
+0010909,私放在押人员罪
+0010910,失职致使在押人员脱逃罪
+0010911,徇私舞弊减刑、假释、暂予监外执行罪
+0010912,徇私舞弊不移交刑事案件罪
+0010913,滥用管理公司、证券职权罪
+0010914,徇私舞弊不征、少征税款罪
+0010915,徇私舞弊发售发票、抵扣税款、出口退税罪
+0010916,违法提供出口退税凭证罪
+0010917,国家机关工作人员签订、履行合同失职被骗罪
+0010918,违法发放林木采伐许可证罪
+0010919,环境监管失职罪
+0010920,传染病防治失职罪
+0010921,非法批准征用、占用土地罪
+0010922,非法低价出让国有土地使用权罪
+0010923,放纵走私罪
+0010924,商检徇私舞弊罪
+0010925,商检失职罪
+0010926,动植物检疫徇私舞弊罪
+0010927,动植物检疫失职罪
+0010928,放纵制售伪劣商品犯罪行为罪
+0010929,办理偷越国（边）境人员出入境证件罪
+0010930,放行偷越国（边）境人员罪
+0010931,不解救被拐卖、绑架妇女、儿童罪
+0010933,帮助犯罪分子逃避处罚罪
+0010934,招收公务员、学生徇私舞弊罪
+0010935,失职造成珍贵文物损毁、流失罪
+0010938,枉法裁判罪
+0010939,国家机关工作人员签订、履行合同失职罪
+0010940,枉法仲裁罪
+0010941,国家机关工作人员徇私舞弊罪
+0010943,食品监管渎职罪
+0011002,隐瞒、谎报军情罪
+0011006,擅离、玩忽军事职守罪
+0011007,阻碍执行军事职务罪
+0011013,为境外窃取、剌探、收买、非法提供军事秘密罪
+0011018,逃离部队罪
+0011021,盗窃、抢夺武器装备、军用物资罪
+0011025,擅自出卖、转让军队房地产罪
+0011026,虐待部属罪
+0019799,商业受贿罪
+001030101,生产、销售伪劣产品罪
+001030102,生产、销售假药罪
+001030103,生产、销售劣药罪
+001030104,生产、销售不符合卫生标准的食品罪
+001030105,生产、销售有毒、有害食品罪
+001030106,生产、销售不符合标准的医用器材罪
+001030107,生产、销售不符合安全标准的产品罪
+001030108,生产、销售伪劣农药、兽药、化肥、种子罪
+001030109,生产、销售不符合卫生标准的化妆品罪
+001030110,生产、销售不符合安全标准的食品罪
+001030201,走私武器、弹药罪
+001030203,走私假币罪
+001030204,走私文物罪
+001030205,走私贵重金属罪
+001030206,走私珍贵动物、珍贵动物制品罪
+001030207,走私珍稀植物、珍稀植物制品罪
+001030208,走私淫秽物品罪
+001030209,走私普通货物、物品罪
+001030210,走私废物罪
+001030211,走私固体废物罪
+001030212,走私国家禁止进出口的货物、物品罪
+001030301,虚报注册资本罪
+001030302,虚假出资、抽逃出资罪
+001030305,妨害清算罪
+001030306,隐匿、故意销毁会计凭证、会计帐簿、财务会计报告罪
+001030309,非法经营同类营业罪
+001030310,为亲友非法牟利罪
+001030311,签订、履行合同失职被骗罪
+001030312,国有公司、企业、事业单位人员失职罪
+001030313,国有公司、企业、事业单位人员滥用职权罪
+001030314,徇私舞弊低价折股、出售国有资产罪
+001030316,违规披露、不披露重要信息罪
+001030317,虚假破产罪
+001030318,非国家工作人员受贿罪
+001030319,对非国家工作人员行贿罪
+001030320,背信损害上市公司利益罪
+001030401,伪造货币罪
+001030402,出售、购买、运输假币罪
+001030403,金融工作人员购买假币、以假币换取货币罪
+001030404,持有、使用假币罪
+001030405,变造货币罪
+001030406,擅自设立金融机构罪
+001030407,伪造、变造、转让金融机构经营许可证、批准文件罪
+001030408,高利转贷罪
+001030409,非法吸收公众存款罪
+001030410,伪造、变造金融票证罪
+001030411,伪造、变造国家有价证券罪
+001030412,伪造、变造股票、公司、企业债券罪
+001030413,擅自发行股票、公司、企业债券罪
+001030414,内幕交易、泄露内幕信��罪
+001030415,编造并传播证券、期货交易虚假信息罪
+001030417,操纵证券、期货交易价格罪
+001030418,骗购外汇罪
+001030419,违法向关系人发放贷款罪
+001030420,违法发放贷款罪
+001030422,非法出具金融票证罪
+001030423,对违法票据承兑、付款、保证罪
+001030424,逃汇罪
+001030425,洗钱罪
+001030426,骗取贷款、票据承兑、金融票证罪
+001030427,妨害信用卡管理罪
+001030428,窃取、收买、非法提供信用卡信息罪
+001030429,操纵证券、期货市场罪
+001030431,违法运用资金罪
+001030434,违规出具金融票证罪
+001030435,利用未公开信息交易罪
+001030501,集资诈骗罪
+001030502,贷款诈骗罪
+001030503,票据诈骗罪
+001030504,金融凭证诈骗罪
+001030505,信用证诈骗罪
+001030506,信用卡诈骗罪
+001030507,有价证券诈骗罪
+001030508,保险诈骗罪
+001030601,偷税罪
+001030602,抗税罪
+001030603,逃避追缴欠税罪
+001030604,骗取出口退税罪
+001030605,虚开增值税专用发票、用于骗取出口退税、抵押税款发票罪
+001030606,伪造、出售伪造的增值税专用发票罪
+001030607,非法出售增值税专用发票罪
+001030608,非法购买增值税专用发票、购买伪造的增值税专用发票罪
+001030609,非法制造、出售非法制造的用于骗取出口退税、抵押税款发票罪
+001030610,非法制造、出售非法制造的发票罪
+001030611,非法出售用于骗取出口退税、抵扣税款发票罪
+001030612,非法出售发票罪
+001030613,逃税罪
+001030614,虚开发票罪
+001030615,持有伪造的发票罪
+001030701,假冒注册商标罪
+001030702,销售假冒注册商标的商品罪
+001030703,非法制造、销售非法制造的注册商标标识罪
+001030704,假冒专利罪
+001030705,侵犯著作权罪
+001030706,销售侵权复制品罪
+001030707,侵犯商业秘密罪
+001030801,损害商业信誉、商品声誉罪
+001030802,虚假广告罪
+001030803,串通投标罪
+001030804,合同诈骗罪
+001030805,非法经营罪
+001030806,强迫交易罪
+001030807,伪造、倒卖伪造的有价票证罪
+001030808,倒卖车票、船票罪
+001030809,非法转让、倒卖土地使用权罪
+001030810,提供虚假证明文件罪
+001030811,出具证明文件重大失实罪
+001030812,逃避商检罪
+001030813,组织、领导传销活动罪
+001060101,妨害公务罪
+001060102,煽动暴力抗拒法律实施罪
+001060103,招摇撞骗罪
+001060104,伪造、变造、买卖国家机关公文、证件、印章罪
+001060105,盗窃、抢夺、毁灭国家机关公文、证件、印章罪
+001060106,伪造公司、企业、事业单位、人民团体印章罪
+001060107,伪造、变造居民身份证罪
+001060108,非法生产、买卖警用装备罪
+001060109,非法获取国家秘密罪
+001060110,非法持有国家绝密、机密文件、资料、物品罪
+001060112,非法使用窃听、窃照专用器材罪
+001060113,非法侵入计算机信息系统罪
+001060114,破坏计算机信息系统罪
+001060115,扰乱无线电通讯管理秩序罪
+001060116,聚众扰乱社会秩序罪
+001060117,聚众冲击国家机关罪
+001060118,聚众扰乱公共场所秩序、交通秩序罪
+001060119,投放虚假危险物质罪
+001060120,聚众斗殴罪
+001060121,寻衅滋事罪
+001060122,组织、领导、参加黑社会性质组织罪
+001060123,入境发展黑社会组织罪
+001060124,包庇、纵容黑社会性质组织罪
+001060125,传授犯罪方法罪
+001060126,非法集会、游行、示威罪
+001060129,侮辱国旗、国徽罪
+001060130,组织、利用会道门、邪教组织、利用迷信破坏法律实施罪
+001060131,组织、利用会道门、邪教组织利用迷信致人死亡罪
+001060132,聚众淫乱罪
+001060133,引诱未成年人聚众淫乱罪
+001060135,赌博罪
+001060137,编造、故意传播虚假恐怖信息罪
+001060138,开设赌场罪
+001060139,非法获取计算机信息系统数据、非法控制计算机信息系统罪
+001060140,提供侵入、非法控制计算机信息系统程序、工具罪
+001060141,伪造、变造、买卖身份证件罪
+001060142,使用虚假身份证件、盗用身份证件罪
+001060143,非法生产、销售专用间谍器材、窃听、窃照专用器材罪
+001060144,组织考试作弊罪
+001060145,非法出售、提供试题、答案罪
+001060146,代替考试罪
+001060148,非法利用信息网络罪
+001060149,帮助信息网络犯罪活动罪
+001060150,扰乱国家机关工作秩序罪
+001060151,组织、资助非法聚集罪
+001060152,编造、故意传播虚假信息罪
+001060154,盗窃、侮辱、故意毁坏尸体、尸骨、骨灰罪
+001060201,伪证罪
+001060202,辩护人、诉讼代理人毁灭证据、伪造证据、妨害作证罪
+001060203,妨害作证罪
+001060204,帮助毁灭、伪造证据罪
+001060205,打击报复证人罪
+001060206,扰乱法庭秩序罪
+001060207,窝藏、包庇罪
+001060209,窝藏、转移、收购���销售赃物罪
+001060210,拒不执行判决、裁定罪
+001060211,非法处置查封、扣押、冻结的财产罪
+001060212,破坏监管秩序罪
+001060213,脱逃罪
+001060214,劫夺被押解人员罪
+001060215,组织越狱罪
+001060216,暴动越狱罪
+001060217,聚众持械劫狱罪
+001060218,掩饰、隐瞒犯罪所得、犯罪所得收益罪
+001060219,虚假诉讼罪
+001060301,组织他人偷越国（边）境罪
+001060302,骗取出境证件罪
+001060303,提供伪造、变造的出入境证件罪
+001060304,出售出入境证件罪
+001060305,运送他人偷越国（边）境罪
+001060306,偷越国（边）境罪
+001060401,故意损毁文物罪
+001060402,故意损毁名胜古迹罪
+001060403,过失损毁文物罪
+001060404,非法向外国人出售、赠送珍贵文物罪
+001060405,倒卖文物罪
+001060406,非法出售、私赠文物藏品罪
+001060407,盗掘古文化遗址、古墓葬罪
+001060408,盗掘古人类化石、古脊椎动物化石罪
+001060409,抢夺、窃取国有档案罪
+001060410,擅自出卖、转让国有档案罪
+001060504,非法组织卖血罪
+001060505,强迫卖血罪
+001060506,非法采集、供应血液、制作、供应血液制品罪
+001060508,医疗事故罪
+001060509,非法行医罪
+001060510,非法进行节育手术罪
+001060512,妨害动植物防疫、检疫罪
+001060601,重大环境污染事故罪
+001060602,非法处置进口的固体废物罪
+001060603,擅自进口固体废物罪
+001060604,非法捕捞水产品罪
+001060605,非法猎捕、杀害珍贵、濒危野生动物罪
+001060606,非法收购、运输、出售珍贵、濒危野生动物、珍贵、濒危野生动物制品罪
+001060607,非法狩猎罪
+001060608,非法占用农用地罪
+001060609,非法采矿罪
+001060610,破坏性采矿罪
+001060611,非法采伐、毁坏国家重点保护植物罪
+001060612,非法收购、运输、加工、出售国家重点保护植物、国家重点保护植物制品罪
+001060613,盗伐林木罪
+001060614,滥伐林木罪
+001060615,非法收购、运输盗伐、滥伐的林木罪
+001060616,非法占用耕地罪
+001060617,非法采伐、毁坏珍贵树木罪
+001060618,非法收购盗伐、滥伐的林木罪
+001060619,污染环境罪
+001060701,走私、贩卖、运输、制造毒品罪
+001060702,非法持有毒品罪
+001060703,包庇毒品犯罪分子罪
+001060704,窝藏、转移、隐瞒毒品、毒赃罪
+001060705,走私制毒物品罪
+001060706,非法买卖制毒物品罪
+001060707,非法种植毒品原植物罪
+001060708,非法买卖、运输、携带、持有毒品原植物种子、幼苗罪
+001060709,引诱、教唆、欺骗他人吸毒罪
+001060710,强迫他人吸毒罪
+001060711,容留他人吸毒罪
+001060712,非法提供麻醉药品、精神药品罪
+001060713,非法生产、买卖、运输制毒物品、走私制毒物品罪
+001060801,组织卖淫罪
+001060802,强迫卖淫罪
+001060803,协助组织卖淫罪
+001060804,引诱、容留、介绍卖淫罪
+001060805,引诱幼女卖淫罪
+001060806,传播性病罪
+001060901,制作、复制、出版、贩卖、传播淫秽物品牟利罪
+001060903,传播淫秽物品罪
+001060904,组织播放淫秽音像制品罪
+001060905,组织淫秽表演罪
+001970201,破坏通讯设备罪
+001970302,伪造货币或贩运伪造的货币罪
+001970303,伪造车票、船票、邮票、税票、货票罪
+001970304,破坏集体生产罪
+001970401,拐卖人口罪
+001970801,徇私舞弊罪

code/configs/hyperparametric.py

@@ -0,0 +1,45 @@
+
+class Generate_config():
+    def __init__(self):
+        self.max_length = 2048
+        self.truncation = True
+        self.do_sample = True
+        self.max_new_tokens = 1024
+        self.temperature = 0.7
+        self.output_hidden_states = True,  
+        self.return_dict_in_generate = True
+        self.output_logits=True
+    
+    def to_dict(self):
+        return self.__dict__
+
+class Reward_config():
+    def __init__(self):
+        self.max_length = 2048
+        self.truncation = True
+        self.do_sample = True
+        self.max_new_tokens = 10
+        self.temperature = 0.7
+        self.padding = True
+        self.output_hidden_states = True,  
+        self.return_dict_in_generate = True
+        self.output_logits=True
+
+        self.open_tag = '<v>'
+        self.close_tag = '</v>'
+        self.lower = 0
+        self.upper = 100
+
+    def to_dict(self):
+        return self.__dict__
+
+class Tree_config():
+    def __init__(self):
+        self.max_depth = 5
+        self.branch = 5
+    
+    def to_dict(self):
+        return self.__dict__
+
+    
+

code/main.py

@@ -0,0 +1,383 @@
+import os
+import sys
+import argparse
+import logging
+import time
+import json
+
+#os.environ["CUDA_VISIBLE_DEVICES"] = "1"
+
+from peft import PeftModel,LoraConfig, get_peft_model, prepare_model_for_kbit_training
+from transformers import AutoTokenizer, AutoModelForCausalLM, Trainer, TrainingArguments, BitsAndBytesConfig
+from datasets import load_dataset,Dataset
+import torch
+
+from utils.warp import Warp,WarpLJP
+from utils.dataset import DataCollatorForReward
+from utils.trainer import PRGTrainer
+from tree.base import Tree,Node,I_policy
+from configs.hyperparametric import Reward_config,Tree_config
+from model.logitsprocessor import OutputControlLogitsProcessor,RewardControlLogitsProcessor
+from tree.asts import AST
+from utils.model_generate import generate_string,generate_score
+
+tree_config = Tree_config().to_dict()
+#reward_config = Reward_config().to_dict()
+
+import torch
+#torch.cuda.set_device(0)
+
+
+#TASKS = ['ecthr_a','ecthr_b']
+TASKS = ['ljp',]
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+
+    ## ___datasets___
+    #parser.add_argument('--data_path',default='lex_glue',type=str, help='Path containing dataset')
+    parser.add_argument('--train_path',default='',type=str, help='Path containing dataset')
+    parser.add_argument('--eval_path',default='',type=str, help='Path containing dataset')
+    parser.add_argument('--test_path',default='',type=str, help='Path containing dataset')
+    parser.add_argument('--dataset',default='ljp',type=str, help='Dataset of choice in data_path')
+    parser.add_argument('--save_data_path',default='',type=str, help='The path used to save dataset')
+    parser.add_argument('--output_path',default='',type=str, help='The path used to save outputs')
+    parser.add_argument('--sample_path',default='',type=str, help='The path used to samples')
+    parser.add_argument('--control_file',default='./codekey_proofread.txt',type=str, help='The path used to output control')
+
+    ## ___model___
+    parser.add_argument('--generate_model_path',default='',type=str, help='Path containing model')
+    parser.add_argument('--reward_model_path',default='',type=str, help='Path containing model')
+    parser.add_argument('--reward_save_path',default='./output/reward',type=str, help='Path containing model')
+    parser.add_argument('--reward_lora_path',default='',type=str,)
+    parser.add_argument('--per_device_train_batch_size',default=2,type=int)
+    parser.add_argument('--gradient_accumulation_steps',default=2,type=int)
+    parser.add_argument('--learning_rate',default=1e-3,type=float)
+    parser.add_argument('--num_train_epochs',default=10,type=int)
+    parser.add_argument('--logging_steps',default=200,type=int)
+    parser.add_argument('--save_strategy',default='epoch',type=str,)
+    parser.add_argument('--fp16',action='store_true',default=True,)
+    parser.add_argument('--optim',default='paged_adamw_8bit',type=str,)
+    
+    parser.add_argument('--lora_rank',default=64,type=int)
+    parser.add_argument('--lora_alpha',default=16,type=int)
+    parser.add_argument('--lora_dropout',default=0.1,type=float)
+
+    ## ___pipline___
+    parser.add_argument('--do_train',action='store_true',default=False, help='Training or not')
+    parser.add_argument('--do_test',action='store_true',default=True, help='Eval or not')
+
+    ## ___parameter___
+    parser.add_argument('--budget',default=20,type=int, help='iterations of search')
+    parser.add_argument('--reward_funcation',default='leaf',type=str,choices=['random','reward','leaf'], help='iterations of search')
+    parser.add_argument('--iteration',default=3,type=int, help='iterations of sample')
+
+    ## ___special___
+    parser.add_argument('--ljp_mode',default='p',type=str,choices=['p','pd','pdf'])
+    parser.add_argument('--logits_control',action='store_true',default=False, help='Training or not')
+    parser.add_argument('--add_reward',action='store_true',default=False,)
+    parser.add_argument('--inference_mode',default='zeroshot',type=str,choices=['zeroshot','fewshot','cot'])
+
+
+
+    return parser.parse_args()
+
+def get_logger(path='./'):
+    log_path = os.path.join(path,"log_%s.txt"%(time.strftime("%Y-%m-%d-%H-%M-%S",time.localtime())))
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        handlers=[logging.StreamHandler(sys.stdout),
+                  logging.FileHandler(log_path)],
+    )
+    logger = logging.getLogger(__name__)
+    logger.setLevel(level=logging.DEBUG)
+    return logger
+
+def load_data(args):
+    if os.path.isdir(args.train_path):
+        save_path = os.path.join(args.save_data_path,args.dataset)
+        if not os.path.exists(save_path):
+            dataset = load_dataset(path=args.train_path,name=args.dataset)
+            dataset.save_to_disk(save_path)
+        else:
+            dataset = load_dataset(save_path)
+    if os.path.isfile(args.train_path):
+        data_files = {mode:path for mode,path
+                      in zip(['train','validation','test'],[args.train_path,args.eval_path,args.test_path])
+                      if path}
+        dataset = load_dataset('json',data_files=data_files)
+    return dataset
+
+def load_samples(sample_path,):
+    path_list = os.listdir(sample_path)
+    samples = []
+    for path in path_list:
+        path = os.path.join(sample_path,path)
+        with open(path,'r') as f:
+            for l in f.readlines():
+                sample = json.loads(l)
+                samples.append(sample)
+    return samples
+
+
+
+def train(args,warp,dataset,):
+    # init TrainingArgument
+    training_args = TrainingArguments(
+        output_dir=os.path.join(args.reward_save_path,'reward_%s'%(time.strftime("%Y-%m-%d-%H-%M-%S",time.localtime()))),
+        per_device_train_batch_size=args.per_device_train_batch_size,
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        learning_rate=args.learning_rate,
+        num_train_epochs=args.num_train_epochs,
+        logging_steps=args.logging_steps,
+        save_strategy=args.save_strategy,
+        fp16=args.fp16,
+        optim=args.optim,
+        remove_unused_columns=False
+        )
+    
+    bnb_config = BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_compute_dtype=torch.float16,
+        bnb_4bit_use_double_quant=True,
+        bnb_4bit_quant_type="nf4",
+        llm_int8_threshold=6.0,
+        llm_int8_has_fp16_weight=False, 
+        )
+
+    peft_config = LoraConfig(
+        r=args.lora_rank,
+        lora_alpha=args.lora_alpha,
+        lora_dropout=args.lora_dropout,
+        target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
+        bias="none",
+        task_type="CAUSAL_LM"
+        )
+
+    # init model
+    if not warp.reward_model:
+        warp.load_reward_model(bnb_config=bnb_config)
+
+    model = warp.reward_model
+    tokenizer = warp.reward_tokenizer
+
+    model = prepare_model_for_kbit_training(model)
+    model = get_peft_model(model, peft_config)
+
+    # init collator
+    collator = DataCollatorForReward(tokenizer=tokenizer)
+    logits_processor = RewardControlLogitsProcessor(tokenizer=tokenizer)
+
+    # init dataset
+    trainset = dataset['0']
+
+    # init trainer
+    trainer = PRGTrainer(
+            tokenizer=tokenizer,
+            model=model,
+            args=training_args,
+            train_dataset=trainset,
+            data_collator=collator,
+            logits_processor=logits_processor
+        )
+    
+    # clean memory 
+    warp.generate_model = None
+    torch.cuda.empty_cache()
+
+    # training
+    logger.info('start training..')
+    for i,trainset in dataset.items():
+        if i != '0':
+            trainer.train_dataset = trainset
+        
+        trainer.train()
+
+    logger.info('training end..')
+    warp.reward_model = model
+    warp.reward_tokenizer = tokenizer
+
+def evaluate(args,warp,dataset,):
+    if warp.generate_model == None:
+        warp.load_generate_model()
+    if args.add_reward:
+        if args.reward_lora_path != '':
+            bnb_config = BitsAndBytesConfig(load_in_4bit=True,
+                                            bnb_4bit_compute_dtype=torch.float16,
+                                            bnb_4bit_use_double_quant=True,
+                                            bnb_4bit_quant_type="nf4",
+                                            llm_int8_threshold=6.0,
+                                            llm_int8_has_fp16_weight=False,
+                                            )
+            warp.load_reward_model(bnb_config=bnb_config)
+            warp.reward_model = PeftModel.from_pretrained(warp.reward_model, args.reward_lora_path) 
+        else:
+            warp.load_reward_model()
+        rewarder = {'model':warp.reward_model,'tokenizer':warp.reward_tokenizer,}
+        if args.logits_control:
+            rewarder['reward_processor'] = RewardControlLogitsProcessor(tokenizer=rewarder['tokenizer'])
+    else:
+        rewarder = {}
+
+    model = warp.generate_model
+    tokenizer = warp.generate_tokenizer
+    
+    def get_response(x,a,tokenizer,model,rewarder={}):
+        if rewarder == {}:
+            inputs = warp.prompt_to_crime(x,a,bos=tokenizer.bos_token,eos=tokenizer.eos_token)
+            if args.logits_control:
+                outputs = generate_string(inputs,tokenizer=tokenizer,model=model,logits_processor=warp.logits_processor)
+            else:
+                outputs = generate_string(inputs,tokenizer=tokenizer,model=model,)
+
+            response = warp.step_from_response(outputs)
+            return response
+        if 'reward_processor' not in rewarder.keys():
+            rewarder['reward_processor'] = None
+        
+        for i in range(tree_config['branch']):
+            inputs = warp.prompt_to_crime(x,a,bos=tokenizer.bos_token,eos=tokenizer.eos_token)
+            if args.logits_control:
+                outputs = generate_string(inputs,tokenizer=tokenizer,model=model,logits_processor=warp.logits_processor)
+            else:
+                outputs = generate_string(inputs,tokenizer=tokenizer,model=model,)
+            response = warp.step_from_response(outputs)
+            
+            thought = warp.prompt_to_value(x,a+response,bos=rewarder['tokenizer'].bos_token,eos=rewarder['tokenizer'].eos_token)
+            reward = generate_score(thought,
+                                    tokenizer=rewarder['tokenizer'],
+                                    model=rewarder['model'],
+                                    reward_processor=rewarder['reward_processor']
+                                    )
+            r = warp.value_from_response(reward)
+            if '拒绝' in r:
+                continue
+            else:
+                break
+        return response
+    
+    logger.info('start eval..')
+    time_start = time.time()
+    reward_control = 'rewardcontrol' if args.add_reward else 'un-reward'
+    task_name = args.test_path.split('/')[-2]
+    save_path = os.path.join(args.output_path,'eval',"%s_%s_%s_%s.json"%(task_name,args.inference_mode,reward_control,time.strftime("%Y-%m-%d-%H-%M-%S",time.localtime())))
+    
+    preds = []
+    for i,data in enumerate(dataset):
+        x,a,y = warp.processing_single(data)
+        if args.inference_mode == 'fewshot':
+            x = '这是一个例子：根据案情描述和已有步骤仅给出一个推理。如果是结论则直接输出<e></e>，例如<e>盗窃罪</e>。如果是步骤则直接输出<p></p>，例如<p>步骤1：…</p>\n案情描述:2013年下半年至2015年10月26日，被告人张和菊利用担任山东泰开电力建设工程有限公司、山东泰开国际工程技术有限公司现金出纳的职务便利，多次将公司的资金共计4472572.91元挪出，用于其在深圳石油化工交易所、天津渤海商品交易所的投资交易，已全部亏损。2015年10月26日，张和菊从公司提取现金26万元后，携款潜逃至济南市长清区租房处藏匿。2015年11月6日，张和菊被公安机关抓获。\n已有推理步骤：\n<e>挪用资金罪</e>\n这是问题:\n根据案情描述和已有步骤仅给出一个推理。如果是结论则直接输出<e></e>，例如<e>盗窃罪</e>。如果是步骤则直接输出<p></p>，例如<p>步骤1：…</p>\n案情描述:'+x
+        elif args.inference_mode == 'cot':
+            x = '一步步思考并回答，' + x
+        y = y['crime']
+        a = ''
+        for d in range(tree_config['max_depth']):
+            try:
+                response = get_response(x,a,tokenizer,model,rewarder=rewarder)
+            except Exception as E:
+                response = ''     
+            if '<e>' in response:
+                break
+            if '<p>' in response:
+                a += response
+        y_ = response
+        preds.append({'x':x,'y':y,'pred':y_})
+
+        if i % args.logging_steps == 0:
+            logger.info('{x}'.format(x=str({'x':x,'y':y,'pred':y_})))
+    
+    logger.info('eval: save...')
+    with open(save_path,'w') as file:
+        for l in preds:
+            line = json.dumps(l,ensure_ascii=False)
+            file.write(line)
+            file.write('\n')
+    time_end = time.time()
+    logger.info('reward_eval : {x} '.format(x=args.reward_model_path))
+    logger.info('save_eval : {x} '.format(x=save_path))
+    logger.info('running time: {x}'.format(x=time_end-time_start))
+    logger.info('eval: fin')
+
+def sample(args,warp):
+
+    # load datset
+    logger.info('load datset..')
+    dataset = load_data(args)
+
+    logger.info('start sampling..')
+    samples = {}
+    for iter in range(args.iteration):
+        logger.info('iter_{x}'.format(x=iter))
+        
+        train_samples = []
+
+        sample_path = 'branch{b}_deep{d}_budget{g}_iter{i}'.format(b=tree_config['branch'],d=tree_config['max_depth'],g=args.budget,i=iter)
+        if args.sample_path != '' and sample_path in os.listdir(args.sample_path):
+            sample_path = os.path.join(args.sample_path,sample_path)
+            train_samples += load_samples(sample_path)
+
+        else:
+            save_path = os.path.join(args.output_path,'data',
+                             'branch{b}_deep{d}_budget{g}_iter{i}'.format(b=tree_config['branch'],d=tree_config['max_depth'],g=args.budget,i=iter),
+                             )
+            os.makedirs(save_path) if not os.path.exists(save_path) else None
+            for i,sample in enumerate(dataset['train']):
+
+                time_start = time.time()
+  
+                tree_of_sample = Tree(sample=sample,warp=warp) 
+                tree_of_sample.monte_carlo_tree_search(budget=args.budget,reward_funcation=args.reward_funcation)
+                #train_samples += tree_of_sample.sample(attribute='positive')
+        
+                save_path = os.path.join(args.output_path,'data',
+                                         'branch{b}_deep{d}_budget{g}_iter{i}'.format(b=tree_config['branch'],d=tree_config['max_depth'],g=args.budget,i=iter),
+                                         'samples' + time.strftime("-%Y-%m-%d-%H:%M:%S", time.localtime()) + '.json')
+                train_samples += tree_of_sample.save(path=save_path)
+
+                time_end = time.time()
+                logger.info('\nrunning time: {x}'.format(x=time_end-time_start))
+                _example = tree_of_sample.root.x[:50] if len(tree_of_sample.root.x) > 50 else tree_of_sample.root.x
+                logger.info('{i}-th sample: {x}'.format(i=i,x=_example))
+        
+        train_samples = Dataset.from_list(train_samples)
+        samples[str(iter)] = train_samples
+    
+    return samples
+
+
+def run(args):
+    
+    # create framework
+    if args.dataset in ['ljp']:
+        warp = WarpLJP(args=args)
+
+    warp.load_generate_model()
+
+    # load training data
+    #
+
+    # data collection
+    if args.do_train:
+        trainsets = sample(args=args,warp=warp)
+        #raise ValueError
+        train(args,warp,trainsets)
+    # test
+    if args.do_test:
+        datasets = load_data(args)
+        evaluate(args,warp,datasets['test'])
+
+
+
+if __name__ == "__main__":
+    args = get_args()
+    logger = get_logger(args.output_path)
+
+    loginfo = '\n'.join(['{k}: {v}'.format(k=k,v=v) for k,v in vars(args).items()])
+    logger.info(loginfo)
+
+    try:
+        run(args)
+    except Exception as E:
+        logger.exception('{x}'.format(x=E))

code/model/constrainedmodel.py

@@ -0,0 +1,16 @@
+from transformers import DataCollatorForSeq2Seq,LogitsProcessor,LogitsProcessorList, AutoModelForCausalLM
+import torch
+
+class ConstrainedQwenModel(AutoModelForCausalLM):
+    def generate(self, *args, **kwargs):
+        if "logits_processor" not in kwargs:
+            kwargs["logits_processor"] = LogitsProcessorList()
+        
+        kwargs["logits_processor"].append(
+            LogitsProcessor(self.tokenizer)
+        )
+        
+        return super().generate(*args, **kwargs)
+
+if __name__ == '__main__':
+    pass

code/model/logitsprocessor.py

@@ -0,0 +1,132 @@
+import os
+
+from transformers import DataCollatorForSeq2Seq,LogitsProcessor,LogitsProcessorList, AutoModelForCausalLM
+import torch
+
+from tree.asts import ASC,Node
+
+class OutputControlLogitsProcessor(LogitsProcessor):
+    def __init__(self, tokenizer,ast):
+        self.tokenizer = tokenizer
+        self.ast = ast    
+        self.trigger = tokenizer.encode('<e>')[-3:]
+
+    def _get_valid_token_ids(self):       
+        valid_tokens = self.ast.return_next_token()
+        valid_ids = []
+
+        if len(valid_tokens) == 0:
+            return list(range(len(self.tokenizer.get_vocab())))
+        
+        for token in valid_tokens:
+            token_id = self.tokenizer.convert_tokens_to_ids(token)
+            if token_id != self.tokenizer.unk_token_id:
+                valid_ids.append(token_id)
+       
+        return valid_ids
+
+    def __call__(self, input_ids, scores):
+        if input_ids[0,-3:].tolist() != self.trigger:
+            return scores
+        
+        last_token = input_ids[0, -1].item()
+        last_token = self.tokenizer.decode([last_token], skip_special_tokens=False)
+
+        self.ast.update_state(last_token)
+        current_ids = self._get_valid_token_ids()
+
+        mask = torch.full_like(scores, -float(1e10))
+        for ids in current_ids:
+            mask[:, ids] = 0
+             
+        filtered_scores = scores + mask
+        
+        return filtered_scores
+
+class RewardControlLogitsProcessor(LogitsProcessor):
+    def __init__(self, tokenizer, open_tag='<v>',close_tag='</v>',lower=0,upper=100):
+        self.tokenizer = tokenizer
+        
+        open_tag = tokenizer.encode(open_tag, add_special_tokens=False)
+        close_tag = tokenizer.encode(close_tag, add_special_tokens=False)
+        number_tokens = [tokenizer.encode(str(i), add_special_tokens=False) for i in ['接受','拒绝']]
+
+        self.tag_tokens =  {"open_tag": open_tag,"close_tag": close_tag,"label": number_tokens}
+        self.get_tag_chain()
+
+    def get_tag_chain(self):     
+        asc = ASC()
+        current_node = asc.root
+        for i,t in enumerate(self.tag_tokens['open_tag']):
+            node = Node(t)
+            current_node.children[t] = node
+            current_node = node
+        end_node = None
+        end = '</v>'
+        for i,t in enumerate(self.tag_tokens['close_tag']):
+            if i == 0:        
+                end_node = Node(t)
+                _end_node = end_node
+                end = t
+            else:
+                node = Node(t)
+                _end_node.children[t] = node
+                _end_node = node
+            if i == len(self.tag_tokens['close_tag']) - 1:
+                node = Node('')
+                node.end = True
+                _end_node.children[t] = node
+
+        for t in self.tag_tokens['label']:
+            for c in t:
+                node = Node(c)
+                current_node.children[c] = node
+                current_node = node
+            current_node.children[end] = end_node
+
+        self.asc = asc
+   
+    def __call__(self, input_ids, scores):
+        if self.asc.current_node.end:
+            return scores
+
+        last_token = input_ids[0, -1].item()
+        self.asc.update_state(last_token)
+
+        mask = torch.full_like(scores, -float(1e8))
+        for ids in [list(self.asc.current_node.children.keys())]:
+            mask[:, ids] = 0      
+        filtered_scores = scores + mask
+
+        return filtered_scores
+
+if __name__ == '__main__':
+    from transformers import AutoTokenizer, AutoModelForCausalLM
+    from tree.asts import AST
+
+    # 加载模型和tokenizer
+    model_name = ''
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    model = AutoModelForCausalLM.from_pretrained(model_name)
+
+    # 初始化语法树
+    syntax_tree = AST('./codekey_proofread.txt')
+
+    # 创建logits processor
+    logits_processor = OutputControlLogitsProcessor(syntax_tree, tokenizer)
+
+    input_text = "eqwmdsadas乱码"
+    input_ids = tokenizer.encode(input_text, return_tensors="pt")
+
+    output = model.generate(
+    input_ids,
+    max_length=50,
+    do_sample=True,
+    num_return_sequences=1,
+    logits_processor=[logits_processor],
+    pad_token_id=tokenizer.eos_token_id
+)
+
+
+    decoded_output = tokenizer.decode(output[0], skip_special_tokens=False)
+    print(decoded_output)

code/test.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+CUDA_VISIBLE_DEVICES=0 python main.py \
+    --test_path='' \
+    --do_test 
+
+

code/train.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+CUDA_VISIBLE_DEVICES=0 python main.py \
+    --train_path='' \
+    --eval_path='' \
+    --test_path='' \
+    --reward_model_path='' \
+    --add_reward \
+    --do_train 
+
+

code/tree/asts.py

@@ -0,0 +1,85 @@
+from transformers import AutoTokenizer, AutoModelForCausalLM, Trainer, TrainingArguments
+
+import random
+
+class Node():
+    def __init__(self,x):
+        self.x = x
+        self.children = {}
+        self.end = False
+        if x == '罪':
+            self.end = True
+
+class AST():
+    def __init__(self,path,tokenizer):
+        self.root = Node('<e>')
+        self.current_node = self.root
+        self.end_token = '</e>'
+
+        crimes = []
+        with open(path,'r') as f:
+            for l in f.readlines():
+                l = l.strip().split(',')
+                crimes.append(l[1])
+              
+        for crime in crimes:
+            node = self.root
+            crime = tokenizer.tokenize(crime)
+            for char in crime:
+                if char not in [c for c in node.children.keys()]:
+                    node.children[char] = Node(char)
+                node = node.children[char]
+            node.children['</e>'] = Node('</e>')
+    
+    def update_state(self,token):
+        if token in self.current_node.children.keys():
+            self.current_node = self.current_node.children[token]
+        elif token == self.end_token:
+            self.current_node = self.root  # 回到根节点
+        elif token == "<e>":
+            self.current_node = self.root  # 重新开始
+        else:
+            pass
+    
+    def return_next_token(self,):
+        if self.current_node.x == '<e>':
+            return set([o.x for o in self.current_node.children.values()])
+        if self.current_node.end:
+            return set([self.end_token])
+        if self.current_node.x == '</e>':
+            return set([])
+        return set([o.x for o in self.current_node.children.values()])
+
+class ASC():
+    def __init__(self,root='<v>',leaf='</v>'):
+        self.root = Node(root)
+        self.current_node = self.root
+        self.end_token = leaf
+    
+    def update_state(self,token):
+        if token in self.current_node.children.keys():
+            self.current_node = self.current_node.children[token]
+        elif token == '<v>':
+            token = random.choice(list(self.asc.current_node.children.keys()))
+            self.current_node = self.current_node[token]
+        else:
+            pass
+    
+    def return_next_token(self,):
+        if self.current_node.x == '<v>':
+            return set([o.x for o in self.current_node.children.values()])
+        if self.current_node.end:
+            return set([self.end_token])
+        if self.current_node.x == '</v>':
+            return set([])
+        return set([o.x for o in self.current_node.children.values()])
+
+
+
+if __name__ == '__main__':
+    tokenizer = AutoTokenizer.from_pretrained('', trust_remote_code=True)
+    ast = AST('./codekey_proofread.txt',tokenizer)
+    print('-')
+    
+        
+        

code/tree/base.py

@@ -0,0 +1,466 @@
+import random
+import math
+import copy
+import re
+import json
+import torch
+from utils.model_generate import generate_response,generate_string,generate_score
+from utils.warp import Warp
+from configs.hyperparametric import Tree_config
+
+class Node():
+    def __init__(self,x,depth=None,prob=0):
+        # structure  
+        self.parent = None
+        self.children = []
+        self.depth = depth
+        self.visited = 0
+        self.V = 0
+
+        # data
+        self.x = x
+        self.prob = prob
+
+        # attribute
+        self.isReasoning = True if x.startswith('<p>') else False
+        self.isTerminal = True if '<e>' in x else False
+        self.isRoot = False if self.isReasoning or self.isTerminal else True
+
+
+    def add_value(self,V):
+        self.V = self.V + V 
+ 
+    def add_parent(self,x):
+        assert self.parent == None
+        self.parent = x
+
+    def add_children(self,x):
+        if x not in self.children:
+            self.children.append(x)
+        if x.parent == None:
+            x.add_parent(self)
+    
+    def _trace_of_reasoning(self,):
+        if self.isRoot:
+            return self.x
+        elif self.parent != None:
+            x = self.parent._trace_of_reasoning()
+            return '{x}<trace_sp>{a}'.format(x=x,a=self.x)
+    
+    def trace_of_reasoning(self,none_token='<p>无</p>'):
+        trace = self._trace_of_reasoning().split('<trace_sp>')
+        if self.isRoot:
+            x,a = trace[0],[none_token]
+        else:
+            x,a = trace[0],trace[1:]
+        return x,a
+    
+    def pedigree(self,):
+        r = []
+        node = self
+        while True:
+            r.append(node)
+            if node.parent:
+                node = node.parent
+            else:
+                break
+        return r
+              
+
+class Tree():
+    #def __init__(self,x,generater_model,processer,y=None,a=['<p>无</p>']):
+    def __init__(self,sample,warp,):
+        #y=None,a=['<p>无</p>']
+        config = Tree_config()
+
+        # structure  
+        self.max_depth = config.max_depth
+        self.branch = config.branch
+
+        # reward
+        self.reward_funcation = None
+        self.reward_upper = None
+        self.reward_lower = None
+        self.alpha_restmcts = 0.5
+
+        # tool
+        self.warp = warp
+
+
+        # parameter
+        self.reward_funcation = None
+            
+        # sign
+        self.none_token = self.warp.none_token
+           
+        # init
+        x,a,y = self.warp.processing_single(sample)
+
+        self.root = Node(x,depth=0)
+        self.y = y['crime']
+
+        if a[0] not in ['<p>无</p>','<p>none</p>']:
+            current_node = self.root
+            for _a in a: 
+                child = Node(x=_a,depth=current_node.depth+1)
+                current_node.add_children(child)
+                current_node = child
+    
+    def isFullyExpanded(self,node):
+        return True if len(node.children) >= self.branch or node.isTerminal else False
+    
+    def set_reward_funcation(self,reward_funcation):
+        self.reward_funcation = reward_funcation
+        if self.reward_funcation == 'reward':
+            self.reward_upper = 1
+            self.reward_lower = 0
+        elif self.reward_funcation == 'leaf':
+            self.reward_upper = 1
+            self.reward_lower = 0
+        else:
+            self.reward_upper = 1
+            self.reward_lower = 0
+
+    def _bestchild_ucb(self,node):
+        if isinstance(node,list):
+            children = node
+            node = children[0].parent
+        else:
+            children = node.children
+        
+        bestValue = 0  
+        bestNodes = []      
+        for child in children:
+            nodeValue = child.V + 0.7 * math.sqrt(
+                2 * math.log(node.visited) / child.visited) if child.visited > 0 else child.V + 1
+            if nodeValue > bestValue:
+                bestValue = nodeValue
+                bestNodes = [child]
+            elif nodeValue == bestValue:
+                bestNodes.append(child)
+        return random.choice(bestNodes)
+
+    def select_bestchild(self,node):
+        depth = node.depth
+        current_node = node
+        while len(current_node.children) != 0 and depth < self.max_depth:
+            current_node = self._bestchild_ucb(current_node)
+            depth += 1
+        
+        if current_node.isTerminal == False:
+            return True, current_node
+        else:
+            return False, current_node
+
+    def select_child(self,node):  
+        depth = node.depth
+        current_node = node
+        while len(current_node.children) != 0 and depth < self.max_depth:
+            unchoice = [c for c in current_node.children if c.visited==0]
+            if len(unchoice) > 0:
+                current_node = self._bestchild_ucb(unchoice)
+            else:
+                current_node = self._bestchild_ucb(current_node)
+            depth += 1
+        
+        if current_node.isTerminal == False and depth < self.max_depth:
+            return True, current_node
+        else:
+            return False, current_node
+    
+    def expand(self,node):
+        x,a = node.trace_of_reasoning()
+        a = '\n'.join(a)
+        inputs = self.warp.prompt_to_crime(x=x,a=a,
+                                           bos=self.warp.generate_bos,
+                                           eos=self.warp.generate_eos) 
+
+        actions = []
+        if len(node.children) > 0:
+            for child in node.children:
+                actions.append({'a':child.x,'p':child.prob})     
+        
+        n = 0
+        while n < self.branch:
+            action = '<p> </p>'
+            for _ in range(3):
+                try:
+                    response = generate_response(inputs,self.warp.generate_model,
+                                                 self.warp.generate_tokenizer,
+                                                 logits_processor=self.warp.logits_processor)
+                    action = self.warp.step_from_response(response['response'])
+                    prob = response['prob'].to('cpu')        
+                    
+                    if action != '</none_response>':
+                        actions.append({'a':action,'p':prob})
+                    break
+                except Exception as e:
+                    action = '<p> </p>'
+                    continue              
+            n += 1
+
+        for action in actions:
+            child = Node(x=action['a'],depth=node.depth+1,prob=action['p'])
+            node.add_children(child)
+        
+        return node
+
+    
+    def greedyt_policy(self,node):
+        simulation_distance = self.max_depth - node.depth
+        depth = 0
+        #current_choice = copy.deepcopy(node)
+        current_choice = node
+        best_choice = None     
+
+        while current_choice.isTerminal == False and depth < simulation_distance:
+            x,a = current_choice.trace_of_reasoning()
+            a = '\n'.join(a)
+            inputs = self.warp.prompt_to_crime(x=x,a=a,
+                                                bos=self.warp.generate_bos,
+                                                eos=self.warp.generate_eos)
+            actions = []
+            n = 0
+            while n < self.branch:
+                action = ''
+                prob = torch.tensor([1],dtype=torch.float32)
+                for _ in range(3):
+                    try:
+                        response = generate_response(inputs,self.warp.generate_model,
+                                                     self.warp.generate_tokenizer,
+                                                     logits_processor=self.warp.logits_processor)
+                        action,prob = response['response'],response['prob'].to('cpu')    
+                        action = self.warp.step_from_response(action)
+                    except Exception:
+                        action = ''
+                        continue
+                    break
+                if action != '</none_response>':
+                    actions.append({'a':action,'p':prob})
+                n += 1
+            if len(actions) == 0:
+                actions.append({'a':'<e></e>','p':prob})
+            
+            best_choice = None  
+            best_value = self.reward_lower
+            for action in actions:
+                child = Node(action['a'],prob=action['p'],depth=node.depth+1)
+                current_choice.add_children(child)
+                if self.reward_funcation == 'reward':
+                    r = self._reward_self_llm(child)
+                elif self.reward_funcation == 'leaf':
+                    r = self._reward_leaf(child)
+                else:
+                    r = self._reward_random(child)
+                if r > best_value:
+                    best_choice = (child,r)
+                    best_value = r        
+                child.V = r
+            
+            current_choice = best_choice[0] if best_choice else random.choice(current_choice.children)       
+            depth += 1
+        
+        if best_choice:
+            reward = best_choice[1]
+        else:
+            if self.reward_funcation == 'reward':
+                reward = self._reward_self_llm(current_choice)
+            elif self.reward_funcation == 'leaf':
+                reward = self._reward_leaf(current_choice)
+            else:
+                reward = self._reward_random(current_choice)
+
+        return reward
+
+    
+    def _back_single(self,node):
+        node.visited += 1
+        child_Vs = [child.V * child.visited for child in node.children]
+        total_num_visits = sum([child.visited for child in node.children])
+        if total_num_visits > 0:
+            node.V = sum(child_Vs) / total_num_visits
+    
+
+    def back_propagate(self, node, reward):
+        if self.reward_funcation == 'reward':
+            node.V = self.alpha_restmcts * node.V + (1 - self.alpha_restmcts) * reward
+            node.visited += 1
+            node = node.parent
+        elif self.reward_funcation == 'leaf':
+            node.V = reward
+            node.visited += 1
+            node = node.parent
+
+        while node != None:
+            self._back_single(node)
+            node = node.parent
+    
+    def _reward_leaf(self,node):
+        reward = 0
+        ylist = self.y.split(';')
+        for y in ylist:
+            if re.search(y,node.x):
+                return 1
+            if re.search('<e>.*{x}.*</e>'.format(x=y[3:-4]),node.x):
+                return 1
+
+        return reward
+    
+    def _reward_random(self,node):
+        return random.uniform(-1,1)
+    
+    def _reward_self_llm(self,node):
+        x,a = node.trace_of_reasoning()
+        a = '\n'.join(a)
+        inputs = self.warp.prompt_to_value(x=x,a=a,
+                                                bos=self.warp.generate_bos,
+                                                eos=self.warp.generate_eos)
+        score = 0.0
+        for _ in range(3):
+            try:
+                score = generate_score(inputs,self.warp.generate_model,self.warp.generate_tokenizer)
+                score = self.warp.value_from_response(score)
+            except Exception:
+                score = 0.0
+                continue
+            if score:
+                break
+        return score
+    
+    def _reward_extra_llm(self,node):
+        x,a = node.trace_of_reasoning()
+        a = '\n'.join(a)
+        inputs = self.warp.prompt_to_value(x=x,a=a,
+                                                bos=self.warp.generate_bos,
+                                                eos=self.warp.generate_eos)
+        score = 0.0
+        for _ in range(3):
+            try:
+                score = generate_score(inputs,self.reward_model,self.reward_tokenizer)
+                score = self.warp.value_from_response(score)
+            except Exception:
+                score = 0.0
+                continue
+            if score:
+                break
+        return score
+
+    def monte_carlo_tree_search(self,root=None,budget=10,reward_funcation='random'):
+        if not root:
+            root = self.root
+        if reward_funcation in ['random','reward','leaf']:
+            self.set_reward_funcation(reward_funcation)
+
+        iteration = 0
+        while iteration < budget:        
+            need_expand,node = self.select_child(root)
+            if need_expand:
+                node = self.expand(node)
+                _,node = self.select_child(node)
+            
+            V = self.greedyt_policy(node)
+            self.back_propagate(node,V)     
+
+            iteration += 1
+        
+    
+    def sample(self,root=None,attribute='positive'):
+        if root is None:
+            root = self.root
+        if attribute == 'positive':
+            _,node = self.select_bestchild(root)
+        elif attribute == 'negative':
+            _,node = self.select_bestchild(root)
+            node.pedigree()[:-1]
+            rdm = random.choice(node.pedigree()[:-1])
+            rdm = [_ for _ in rdm.parent.children if _.x != rdm.x]
+            node = random.choice(rdm) if len(rdm) > 0 else node
+            while len(node.children) > 0:
+                node = random.choice(node.children)
+        else:
+            node = root
+            while len(node.children) > 0:
+                node = random.choice(node.children)
+        
+        train_samples = []
+        trace = node.pedigree()
+        for i,o in enumerate(trace):
+            if i == len(trace) - 1:
+                break
+            text = '\n'.join(reversed([_.x for _ in trace[i:-1]]))
+            text = self.warp.prompt_to_value(x=trace[-1].x,a=text,
+                                                bos=self.warp.generate_bos,
+                                                eos=self.warp.generate_eos)
+            reward = o.V
+            prob = o.prob
+            i_sample = I_policy(o)
+            i_all = self.branch
+            train_samples.append({'text':text,'reward':reward,'I-all':i_all,'I-sample':i_sample,'prob':prob,'visited':o.visited,'y':self.y})
+
+        return train_samples
+
+    def save(self,path=None):
+        root = self.root
+        leaves = []
+
+        def dfs(node):
+            if node not in leaves:
+                leaves.append(node)
+            if len(node.children) == 0:
+                return
+            else:
+                for child in node.children:
+                    dfs(child)
+
+        for child in root.children:
+            dfs(child)
+        
+        samples = []
+        for leaf in leaves:
+            x,a = leaf.trace_of_reasoning()
+            text = '\n'.join(a)
+            text = self.warp.prompt_to_value(x=x,a=text,
+                                             bos=self.warp.generate_bos,
+                                             eos=self.warp.generate_eos)
+            reward = leaf.V
+            prob = leaf.prob.item()
+            i_sample = I_policy(leaf)
+            i_all = self.branch
+            samples.append({'text':text,'reward':reward,'I-all':i_all,'I-sample':i_sample,'prob':prob,'visited':leaf.visited,'y':self.y})
+        
+        if path:
+            with open(path,'w') as f:
+                for sample in samples:
+                    sample = json.dumps(sample,ensure_ascii=False)
+                    f.write(sample)
+                    f.write('\n')
+        
+        return samples
+        
+
+    def inference(self,root=None):
+        if root is None:
+            root = self.root
+        _,node = self.select_bestchild(root)
+
+        if re.search('<e>.*</e>',node.x):
+            y_ = re.search('<e>.*</e>',node.x).group(0)[3:-4]
+        elif re.search('<p>.*</p>',node.x):
+            y_ = re.search('<p>.*</p>',node.x).group(0)[3:-4]
+        else:
+            y_ = 'none'
+
+        return y_
+
+
+def I_policy(node):
+    x = node.x
+    i_sample = len([o for o in node.parent.children if x == o.x])
+    return i_sample
+
+
+
+
+
+    
+

code/utils/dataset.py

@@ -0,0 +1,92 @@
+from torch.utils.data import Dataset
+from transformers import DataCollatorForSeq2Seq,DataCollatorForLanguageModeling,LogitsProcessor,LogitsProcessorList
+import torch
+from torch.nn.utils.rnn import pad_sequence
+
+import re
+
+from utils.warp import Warp
+from configs.hyperparametric import Reward_config
+config = Reward_config().to_dict()
+template_to_qwen = Warp.template_to_qwen
+
+#'system\nYou are a helpful assistant.<｜end▁of▁sentence｜>\n<｜begin▁of▁sentence｜>user\n根据案情描述对给出的已有推理步骤在0至100内打分并在<v></v>中给出分数，例如<v>1</v>\n案情描述:2012年3月份一天，被告人于某生伙同司某、张某戊、张某丁（均另案处理）窜至河南省郑州市，经杜某（另案处理）联系，由于某生出资从马某（另案处理）手中购买500万假银行承兑汇票一张（出票人为江门市林源贸易有限公司，出票日期为2012年2月28日，到期日为2012年8月28日，票号为4020005120580925，收款人为中国矿产有限责任公司，付款行为江门市区农村信用合作联社）。2012年4月16日，被告人于某生将此银行承兑汇票以淄博亚豪博业建陶有限公司名义转让给莱芜市光昊工贸有限公司，获得赃款4765000元。\n已有推理步骤：\n<p>根据案情描述，被告人于某生伙同他人购买并销售假银行承兑汇票，用于谋取巨额利益，符合票据诈骗罪。</p>\n：<｜end▁of▁sentence｜>\n<｜begin▁of▁sentence｜>assistant\n'
+
+def sample_for_feature(feature):
+    if feature['reward'] == 1:
+        return '<v>接受</v><|im_end|>'
+        #return '<v>接受</v>'
+    if feature['reward'] - feature['I-sample'] / feature['I-all'] > 0:
+        return '<v>接受</v><|im_end|>'
+    return '<v>拒绝</v><|im_end|>'
+
+class DataCollatorForReward(DataCollatorForLanguageModeling):
+    def __init__(self,tokenizer):
+        self.tokenizer = tokenizer
+
+    def __call__(self, examples):
+        text = [example['text'] for example in examples]
+        text = [re.sub('已有推理步骤在0至100内打分并在<v></v>中给出分数，例如<v>1</v>','已有推理步骤选择接受或拒绝，并在<v></v>中给出选择，例如<v>接受</v>',t) for t in text]
+
+        labels = [sample_for_feature(example) for example in examples]
+
+        batch_input = self.tokenizer(
+            [t + l for t,l in zip(text,labels)],  
+            truncation=config['truncation'],
+            max_length=config['max_length'], 
+            return_tensors=None,  
+            add_special_tokens=True
+        )
+
+        input_ids,attention_mask = batch_input['input_ids'], batch_input['attention_mask']
+        padding = [max([len(i) for i in input_ids])-len(ids) for ids in input_ids]
+        input_ids = [ids+[self.tokenizer.pad_token_id]*padding[i] for i,ids in enumerate(input_ids)]
+        attention_mask = [ids+[0]*padding[i] for i,ids in enumerate(attention_mask)]
+
+        label_ids,label_mask = [],[]
+        for i, label in enumerate(labels):
+            label = self.tokenizer.encode(label, add_special_tokens=False)      
+            label_ids.append([-100]*len(input_ids[i])+label)
+            label_mask.append([0]*len(input_ids[i])+[1]*len(label))
+            input_ids[i] += label
+            attention_mask[i] += [1] * len(label)
+
+        input_ids = pad_sequence(
+                [torch.tensor(ids) for ids in input_ids],
+                batch_first=True,
+                padding_value=self.tokenizer.pad_token_id,
+            )
+        attention_mask = pad_sequence(
+                [torch.tensor(mask) for mask in attention_mask],
+                batch_first=True,
+                padding_value=0,
+            )
+        label_ids = pad_sequence(
+                [torch.tensor(l) for l in label_ids],
+                batch_first=True,
+                padding_value=-100,
+            )
+        label_mask = pad_sequence(
+                [torch.tensor(mask) for mask in label_mask],
+                batch_first=True,
+                padding_value=0,
+            )
+        
+        batch = {'input_ids':input_ids,'attention_mask':attention_mask,'labels':label_ids,'label_mask':label_mask}
+
+
+        extra_features = [{k: v for k, v in example.items() if k not in ['text','y']}
+                          for example in examples]
+
+        if extra_features and len(extra_features[0]) > 0:
+            for key in extra_features[0].keys():
+                batch[key] = torch.tensor([f[key] for f in extra_features],dtype=torch.float32)
+        
+        if len(batch['input_ids'].shape) > 2:
+            batch['input_ids'] = batch['input_ids'].squeeze(0)
+        if len(batch['attention_mask'].shape) > 2:
+            batch['attention_mask'] = batch['attention_mask'].squeeze(0)
+
+        return batch  
+
+

code/utils/loss.py

@@ -0,0 +1,63 @@
+import torch
+from torch import nn
+import re
+
+#from utils.warp import get_tag_tokens
+from configs.hyperparametric import Reward_config
+
+config = Reward_config().to_dict()
+
+class FormatGradientMasker:
+    def __init__(self, tokenizer, pattern=r"<a>\d</a>"):
+        self.tokenizer = tokenizer
+        self.pattern = re.compile(pattern)
+        self.format_token_ids = self._get_format_tokens()
+        
+    def _get_format_tokens(self):
+        tokens = set()
+        lower,upper = config['lower'],config['upper']
+        for i in range(lower, upper):
+            text = '{s}{_}{e}'.format(s=config['open_tag'],_=i,e=config['close_tag'])
+            token_ids = self.tokenizer.encode(text, add_special_tokens=False)
+            tokens.update(token_ids)
+        return tokens
+    
+    def create_mask(self, input_ids):
+        mask = torch.zeros_like(input_ids, dtype=torch.float32)
+        text = self.tokenizer.decode(input_ids[0], skip_special_tokens=True)
+        
+        for match in self.pattern.finditer(text):
+            start_pos = match.start()
+            end_pos = match.end()
+            match_text = text[start_pos:end_pos]
+            match_tokens = self.tokenizer.encode(match_text, add_special_tokens=False)
+            
+            # 在input_ids中找到匹配位置
+            for i in range(len(input_ids[0]) - len(match_tokens) + 1):
+                if torch.all(input_ids[0, i:i+len(match_tokens)] == torch.tensor(match_tokens).to(input_ids.device)):
+                    mask[0, i:i+len(match_tokens)] = 1
+                    
+        return mask.bool()
+
+class FormatAwareLoss(nn.Module):
+    def __init__(self, tokenizer):
+        super().__init__()
+        self.tokenizer = tokenizer
+        self.ce_loss = nn.CrossEntropyLoss(reduction='none')
+        self.masker = FormatGradientMasker(tokenizer)
+        
+    def forward(self, logits, labels):
+        shift_logits = logits[..., :-1, :].contiguous()
+        shift_labels = labels[..., 1:].contiguous()
+        
+        losses = self.ce_loss(
+            shift_logits.view(-1, shift_logits.size(-1)),
+            shift_labels.view(-1)
+        ).view(shift_labels.shape)
+        
+        mask = self.masker.create_mask(labels[:, :-1])
+        
+        # 只保留格式区域的损失
+        masked_losses = losses * mask.float()
+        
+        return masked_losses.sum() / (mask.sum() + 1e-8)

code/utils/matrix.py

@@ -0,0 +1,310 @@
+import os
+import json
+import re
+import sklearn
+import collections
+from sklearn.metrics import f1_score,accuracy_score
+
+def get_f1(samples):
+    gold,pred = [],[]
+    for sample in samples:
+        if sample['gold'] in sample['pred']:
+            gold.append(sample['gold'])
+            pred.append(sample['gold'])
+        else:
+            gold.append(sample['gold'])
+            pred.append(sample['pred'])
+    
+    micro_f1 = f1_score(gold,pred,average='micro')
+    macro_f1 = f1_score(gold,pred,average='macro')
+
+    
+    print(f"Micro-F1: {micro_f1:.4f}")
+    print(f"Macro-F1: {macro_f1:.4f}")
+    return micro_f1, macro_f1
+
+def get_cls_acc(samples):
+    gold,pred = [],[]
+    for sample in samples:
+        if sample['gold'] in sample['pred']:
+            gold.append(sample['gold'])
+            pred.append(sample['gold'])
+        else:
+            gold.append(sample['gold'])
+            pred.append(sample['pred'])
+    
+    pool = {}
+    for g,p in zip(gold,pred):
+        if g not in pool.keys():
+            pool[g] = {'g':[],'p':[]}
+        pool[g]['g'].append(g)
+        pool[g]['p'].append(p)
+    
+    result = {}
+    counter = {}
+    for k,v in pool.items():
+        g,p = v['g'],v['p']
+        acc = accuracy_score(g,p)
+        result[k] = acc
+        counter[k] = len(g)
+    
+    result = sorted([(k,v,counter[k]) for k,v in result.items()],key=lambda x:x[2],reverse=True)
+
+    #_result = [r for r in result if r[1] > 0]
+    _result = [r for r in result][:20]
+    
+    import pandas as pd
+    prob = [r[1] for r in result]
+    number = [r[2] for r in result]
+    crime = [r[0] for r in result]
+    data = {'crime':crime,'prob':prob,'number':number}
+    df = pd.DataFrame(data)
+    df.to_excel('./output/eval/lawbench.xlsx',index=False)
+
+    for r in result:
+        k,v = r[0],r[1]
+        print('{x} : {y}'.format(x=k,y=v))
+    print(accuracy_score(gold,pred))
+
+def get_bias_with_acc(samples):
+
+    def load_result(path):
+        samples = []
+        samples_with_tag = []
+        with open(path,'r') as f:
+            for l in f.readlines():
+                line = json.loads(l)
+                y = line['y']
+                y_ = line['pred'] if line['pred'] else ''
+
+                y = [s[3:-4] for s in y.split(';')]
+                for c in y:
+                    samples.append({'gold':c,'pred':y_[3:-4]})
+                    if re.search('<e>.*</e>',y_):
+                        samples_with_tag.append({'gold':c,'pred':y_})
+        return samples
+    
+    def get_acc_in_cls(samples):
+        gold,pred = [],[]
+        for sample in samples:
+            if sample['gold'] in sample['pred']:
+                gold.append(sample['gold'])
+                pred.append(sample['gold'])
+            else:
+                gold.append(sample['gold'])
+                pred.append(sample['pred'])
+        pool = {}
+        for g,p in zip(gold,pred):
+            if g not in pool.keys():
+                pool[g] = {'g':[],'p':[]}
+            pool[g]['g'].append(g)
+            pool[g]['p'].append(p)
+    
+        result = {}
+        counter = {}
+        for k,v in pool.items():
+            g,p = v['g'],v['p']
+            acc = accuracy_score(g,p)
+            result[k] = acc
+            counter[k] = len(g)
+    
+        import numpy
+        result = sorted([(k,v,numpy.log(counter[k]/len(gold))) for k,v in result.items()],key=lambda x:x[2],reverse=True)
+
+        return result
+
+    zeroshot = load_result('')       
+    oneshot = load_result('')
+    cot = load_result('')
+    our = load_result('')
+
+    zeroshot = get_acc_in_cls(zeroshot)
+    oneshot = get_acc_in_cls(oneshot)
+    cot = get_acc_in_cls(cot)
+    our = get_acc_in_cls(our)
+    
+    crimes = {c[0]:c[-1] for c in zeroshot}
+    
+    crimes_pool = []
+    log = []
+    acc_zero = []
+    acc_one = []
+    acc_cot = []
+    acc_our = []
+    for c,crime in crimes.items():
+        crimes_pool.append(c)
+        log.append(crime)
+        for i,s in enumerate(zeroshot):
+            if c in s[0]:
+                acc_zero.append(s[1])
+                break
+            if i == len(zeroshot) and c not in s[0]:
+                raise ValueError
+        for i,s in enumerate(oneshot):
+            if c in s[0]:
+                acc_one.append(s[1])
+                break
+            if i == len(oneshot) and c not in s[0]:
+                raise ValueError
+        if len(acc_one) < len(acc_zero):
+            acc_one.append(0)
+        for i,s in enumerate(cot):
+            if c in s[0]:
+                acc_cot.append(s[1])
+                break
+            if i == len(cot) and c not in s[0]:
+                raise ValueError
+        for i,s in enumerate(our):
+            if c in s[0]:
+                acc_our.append(s[1])
+                break
+            if i == len(our) and c not in s[0]:
+                raise ValueError
+
+    import pandas as pd
+    idx = [i for i in range(len(crimes_pool))]
+    data = {'crime':crimes_pool,'prob':log,'zs':acc_zero,'os':acc_one,'ct':acc_cot,'our':acc_our,'id':idx}
+    df = pd.DataFrame(data)
+    df.to_excel('',index=False)
+    
+def get_effect_with_f1():
+    
+    def load_result(path):
+        samples = []
+        samples_with_tag = []
+        with open(path,'r') as f:
+            for l in f.readlines():
+                line = json.loads(l)
+                y = line['y']
+                y_ = line['pred'] if line['pred'] else ''
+
+                y = [s[3:-4] for s in y.split(';')]
+                for c in y:
+                    #crimes_counter[c] += 1
+                    samples.append({'gold':c,'pred':y_[3:-4]})
+                    if re.search('<e>.*</e>',y_):
+                        samples_with_tag.append({'gold':c,'pred':y_})
+        return samples, samples_with_tag
+    
+    dzeroshot,dzeroshottag = load_result('')
+    dzeromi,dzeroma = get_f1(dzeroshot)
+    d_zeromi,d_zeroma = get_f1(dzeroshottag)
+
+    doneshot,doneshottag = load_result('')
+    donemi,donema = get_f1(doneshot)
+    d_onemi,d_onema = get_f1(doneshottag)
+
+    dcotshot,dcotshottag = load_result('')
+    dcotmi,dcotma = get_f1(dcotshot)
+    d_cotmi,d_cotma = get_f1(dcotshottag)
+
+    dourshot,dourshottag = load_result('')
+    dourmi,dourma = get_f1(dourshot)
+    d_ourmi,d_ourma = get_f1(dourshottag)
+    
+    zeroshot,zeroshottag = load_result('')
+    zeromi,zeroma = get_f1(zeroshot)
+    _zeromi,_zeroma = get_f1(zeroshottag)
+
+    oneshot,oneshottag = load_result('')
+    onemi,onema = get_f1(oneshot)
+    _onemi,_onema = get_f1(oneshottag)
+
+    cotshot,cotshottag = load_result('')
+    cotmi,cotma = get_f1(cotshot)
+    _cotmi,_cotma = get_f1(cotshottag)
+
+    ourshot,ourshottag = load_result('')
+    ourmi,ourma = get_f1(ourshot)
+    _ourmi,_ourma = get_f1(ourshottag)
+
+
+    # mi
+    acc_zero_effect = (dzeromi - zeromi) / (dzeromi - zeromi)
+    acc_one_effect = (donemi - zeromi) / (dzeromi - zeromi)
+    acc_cot_effect = (dcotmi - zeromi) / (dzeromi - zeromi)
+    acc_our_effect = (dourmi - zeromi) / (dzeromi - zeromi) 
+        # ma
+    acc_zero_effect = (dzeroma - zeroma) / (dzeroma - zeroma)
+    acc_one_effect = (donema - zeroma) / (dzeroma - zeroma)
+    acc_cot_effect = (dcotma - zeroma) / (dzeroma - zeroma)
+    acc_our_effect = (dourma - zeroma) / (dzeroma - zeroma) 
+
+    print(acc_zero_effect)
+    print(acc_one_effect)
+    print(acc_cot_effect)
+    print(acc_our_effect)  
+
+def crime_topk_acc(samples,crimes=None,name='deepseek'):
+    gold,pred = [],[]
+    for sample in samples:
+        if sample['gold'] in sample['pred']:
+            gold.append(sample['gold'])
+            pred.append(sample['gold'])
+        else:
+            gold.append(sample['gold'])
+            pred.append(sample['pred'])
+    
+    pool = {}
+    for g,p in zip(gold,pred):
+        if g not in pool.keys():
+            pool[g] = {'g':[],'p':[]}
+        pool[g]['g'].append(g)
+        pool[g]['p'].append(p)
+    
+    if crimes is None:
+        crimes = {k:i for i,k in enumerate(pool.keys())}
+    
+    #counter = {}
+    result = {}
+    for k,v in pool.items():
+        counter = collections.Counter()
+        g,p = v['g'],v['p']
+        for pi in p:
+            counter[pi] += 1
+        for c in crimes:
+            if c not in counter.keys():
+                counter[c] = 0
+        result[k] = [counter[c] for c in crimes]
+        
+    import pandas as pd
+    df = pd.DataFrame(result)
+    df.to_excel('./output/eval/warm_acc_{x}.xlsx'.format(x=name),index=False)
+
+    return result,crimes
+
+
+def main():
+    path = ''
+
+    def load_data(path):
+        crimes_counter = collections.Counter()
+        samples = []
+        samples_with_tag = []
+        with open(path,'r') as f:
+            for l in f.readlines():
+                line = json.loads(l)
+                y = line['y']
+                y_ = line['pred'] if line['pred'] else ''
+
+                y = [s[3:-4] for s in y.split(';')]
+                for c in y:
+                    crimes_counter[c] += 1
+                    samples.append({'gold':c,'pred':y_[3:-4]})
+                    if re.search('<e>.*</e>',y_):
+                        samples_with_tag.append({'gold':c,'pred':y_})
+        return samples,samples_with_tag
+
+    samples,samples_with_tag = load_data(path)
+    print('/'.join(path.split('/')[-2:]))
+    get_f1(samples)
+    print('-'*30)
+    get_f1(samples_with_tag)
+    print('-'*30)
+    get_cls_acc(samples)
+    print('-'*30)
+    get_bias_with_acc(samples)
+
+
+if __name__ =='__main__':
+    main()

code/utils/model_generate.py

@@ -0,0 +1,166 @@
+import re
+import logging
+import torch
+import torch.nn.functional as F
+from configs.hyperparametric import Generate_config,Reward_config
+from utils.warp import Warp
+from transformers.generation import GenerateDecoderOnlyOutput
+
+
+logger = logging.getLogger(__name__)
+
+assistant_from_template_in_response = Warp.assistant_from_template_in_response
+config = Generate_config().to_dict()
+reward_config = Reward_config().to_dict()
+
+def extra_span_from_tokens(tokens,sign='e'):
+    start,end = -1,-1
+    for i in range(len(tokens)-3):
+        token = ''.join(tokens[i:i+3])
+        if '<{x}>'.format(x=sign) in token:
+            start = i
+            break 
+    for i in range(len(tokens)-3):
+        token = ''.join(tokens[i:i+3])
+        if '</{x}>'.format(x=sign) in token:
+            end = i+3
+            break
+    if start < end and  0 <= start < len(tokens) and 0 < end < len(tokens):
+        return start, end
+    else:
+        return -1, -1
+
+
+def generate_response(inputs,model,tokenizer,logits_processor=None):
+    ## max_length=2048, truncation=True, max_new_tokens=1024, temperature=0.7, do_sample=False
+    
+    data = tokenizer.encode_plus(inputs,
+                                 max_length=config['max_length'],
+                                 truncation=config['truncation'],
+                                 return_tensors='pt')
+
+    input_ids = data['input_ids'].to('cuda')
+    attention_mask = data['attention_mask'].to('cuda')
+    #bos_token,eos_token = tokenizer.bos_token, tokenizer.eos_token
+
+    if logits_processor:
+        output = model.generate(input_ids, attention_mask=attention_mask,
+                            do_sample=config['do_sample'],
+                            max_new_tokens=config['max_new_tokens'],
+                            temperature=config['temperature'],
+                            output_hidden_states=config['output_hidden_states'],
+                            return_dict_in_generate=config['return_dict_in_generate'],
+                            output_logits=config['output_logits'],
+                            logits_processor=[logits_processor],
+                            bos_token_id=tokenizer.bos_token_id,
+                            eos_token_id=tokenizer.eos_token_id,
+                            pad_token_id=tokenizer.eos_token_id,
+                            )
+    else:
+        output = model.generate(input_ids, attention_mask=attention_mask,
+                            do_sample=config['do_sample'],
+                            max_new_tokens=config['max_new_tokens'],
+                            temperature=config['temperature'],
+                            output_hidden_states=config['output_hidden_states'],
+                            return_dict_in_generate=config['return_dict_in_generate'],
+                            output_logits=config['output_logits'],
+                            bos_token_id=tokenizer.bos_token_id,
+                            eos_token_id=tokenizer.eos_token_id,
+                            pad_token_id=tokenizer.eos_token_id,
+                            )
+    if isinstance(output,GenerateDecoderOnlyOutput):
+        #ori_string = tokenizer.decode(output.sequences[0], skip_special_tokens=False)
+        logits = output.logits
+        #prob = [F.softmax(lgt,dim=-1) for lgt in output.logits]   
+        generated_ids = torch.stack([torch.argmax(logit, dim=-1) for logit in logits], dim=1)
+        generated_tokens = [tokenizer.decode(t,skip_special_tokens=True) for t in generated_ids[0]]
+       
+        # extract probs of the target tokens
+        start,end = extra_span_from_tokens(generated_tokens,'p')
+        if start > 0:
+            logits_thought = [logits[_] for _ in range(start,end)]
+        else:
+            start,end = extra_span_from_tokens(generated_tokens,'e')
+            if start > 0:
+                logits_thought = [logits[_] for _ in range(start,end)]
+
+            else:
+                logits_thought = [logit for logit in logits]
+        
+        prob_thought = [F.softmax(logit,dim=-1) for logit in logits_thought]
+        prob_thought = [torch.amax(logit,dim=-1) for logit in prob_thought]
+        prob_thought = torch.stack(prob_thought).mean(0)
+
+    else:
+        logger.info('GenerateDecoderOnlyOutput error')
+        raise Exception
+    
+    return {'response':''.join(generated_tokens),'prob':prob_thought}
+
+def generate_string(inputs,model,tokenizer,logits_processor=None):
+    ## max_length=2048, truncation=True, max_new_tokens=1024, temperature=0.7, do_sample=False
+
+    data = tokenizer.encode_plus(inputs,
+                                 max_length=config['max_length'],
+                                 truncation=config['truncation'],
+                                 return_tensors='pt')
+
+    input_ids = data['input_ids'].to('cuda')
+    attention_mask = data['attention_mask'].to('cuda')
+    bos_token,eos_token = tokenizer.bos_token, tokenizer.eos_token
+
+    if logits_processor:
+        output = model.generate(input_ids, attention_mask=attention_mask,
+                            do_sample=config['do_sample'],
+                            max_new_tokens=config['max_new_tokens'],
+                            temperature=config['temperature'],
+                            logits_processor=[logits_processor],
+                            bos_token_id=tokenizer.bos_token_id,
+                            eos_token_id=tokenizer.eos_token_id,
+                            pad_token_id=tokenizer.eos_token_id)
+    else:
+        output = model.generate(input_ids, attention_mask=attention_mask,
+                            do_sample=config['do_sample'],
+                            max_new_tokens=config['max_new_tokens'],
+                            temperature=config['temperature'],
+                            bos_token_id=tokenizer.bos_token_id,
+                            eos_token_id=tokenizer.eos_token_id,
+                            pad_token_id=tokenizer.eos_token_id)
+    ori_string = tokenizer.decode(output[0], skip_special_tokens=False)
+    response = assistant_from_template_in_response(x=ori_string,bos=bos_token,eos=eos_token)
+    return response
+
+def generate_score(inputs,model,tokenizer,reward_processor=None):
+    ## max_length=2048, truncation=True, max_new_tokens=1024, temperature=0.7, do_sample=False
+
+    data = tokenizer.encode_plus(inputs,
+                                 max_length=config['max_length'],
+                                 truncation=config['truncation'],
+                                 return_tensors='pt')
+
+    input_ids = data['input_ids'].to('cuda')
+    attention_mask = data['attention_mask'].to('cuda')
+    bos_token,eos_token = tokenizer.bos_token, tokenizer.eos_token
+
+    if reward_processor:
+        output = model.generate(input_ids, attention_mask=attention_mask,
+                            do_sample=reward_config['do_sample'],
+                            max_new_tokens=reward_config['max_new_tokens'],
+                            temperature=reward_config['temperature'],
+                            logits_processor=[reward_processor],
+                            bos_token_id=tokenizer.bos_token_id,
+                            eos_token_id=tokenizer.eos_token_id,
+                            pad_token_id=tokenizer.eos_token_id)
+    else:
+        output = model.generate(input_ids, attention_mask=attention_mask,
+                            do_sample=reward_config['do_sample'],
+                            max_new_tokens=reward_config['max_new_tokens'],
+                            temperature=reward_config['temperature'],
+                            bos_token_id=tokenizer.bos_token_id,
+                            eos_token_id=tokenizer.eos_token_id,
+                            pad_token_id=tokenizer.eos_token_id)
+    ori_string = tokenizer.decode(output[0], skip_special_tokens=False)
+    #response = assistant_from_template_in_response(x=ori_string,bos=bos_token,eos=eos_token)
+    response = ori_string
+    return response
+

code/utils/trainer.py

@@ -0,0 +1,61 @@
+import torch
+import torch.nn as nn
+from transformers import AutoTokenizer, AutoModelForCausalLM, Trainer, TrainingArguments, LogitsProcessor
+from configs.hyperparametric import Reward_config,Tree_config
+from utils.warp import Warp
+from utils.model_generate import extra_span_from_tokens
+#from model.logitsprocessor import RewardControlLogitsProcessor
+
+config = Reward_config().to_dict()
+
+def reinforced_loss(W,V,I_a,I_s,p,lower=1e-3,upper=1-1e-3):
+    prob = I_a / I_s * p
+    #c = W - V
+    W = torch.where(W > lower, W, lower)
+    W = torch.where(W < upper, W, upper)
+
+    return - torch.log(torch.mean(W * prob))
+
+
+class PRGTrainer(Trainer):
+    def __init__(self,tokenizer,logits_processor=None,**kwargs):
+        super(PRGTrainer,self).__init__(**kwargs)
+        self.loss_tokenizer = tokenizer
+        self.logits_processor = logits_processor if logits_processor else LogitsProcessor
+        self.ce = nn.CrossEntropyLoss(ignore_index=-100)
+
+        self.open_tag = tokenizer.encode('<v>',add_special_tokens=False)
+        self.close_tag = tokenizer.encode('</v>',add_special_tokens=False)
+
+        self.state = 'ref'  ## 'ref' or 'sft'
+
+    def compute_loss(self, model, inputs, return_outputs=False,num_items_in_batch=None):
+        V,I_a,I_s,prob = inputs.pop('reward'),inputs.pop('I-all'),inputs.pop('I-sample'),inputs.pop('prob')
+        input_ids,attention_mask = inputs.pop('input_ids'),inputs.pop('attention_mask')
+        labels,label_mask = inputs.pop('labels'),inputs.pop('label_mask')
+        
+        outputs = model(input_ids=input_ids,
+                        attention_mask=attention_mask,
+                        return_dict=config['return_dict_in_generate'],
+                        )
+        logits = outputs.logits
+        logits = torch.softmax(logits,dim=-1)
+
+        shift_logits = logits[..., :-1, :].contiguous()
+        shift_labels = labels[..., 1:].contiguous()
+        shift_label_mask = label_mask[..., 1:].contiguous()
+    
+        batch_label_prob = shift_logits * shift_label_mask.unsqueeze(-1)
+        shift_label_mask = (batch_label_prob != 0).any(dim=-1).any(dim=0)
+        shift_logits = shift_logits[:,shift_label_mask,:]
+        shift_labels = shift_labels[:,shift_label_mask]
+        
+        W = torch.max(shift_logits,dim=-1)[0]
+        W = torch.mean(W,dim=-1)
+
+        loss_ce = self.ce(shift_logits.view(-1, shift_logits.size(-1)),shift_labels.view(-1))
+        loss_fb = reinforced_loss(W=W,V=V,I_a=I_a,I_s=I_s,p=prob)
+
+        loss = loss_ce + loss_fb
+        
+        return (loss, outputs) if return_outputs else loss

code/utils/warp.py

@@ -0,0 +1,148 @@
+import torch
+import re
+from configs.hyperparametric import Reward_config
+
+from transformers import AutoTokenizer, AutoModelForCausalLM, Trainer, TrainingArguments
+from model.logitsprocessor import OutputControlLogitsProcessor,RewardControlLogitsProcessor
+from tree.asts import AST
+
+#reward_config = Reward_config()
+
+def find_subarray_positions(large_array, small_array):
+    n = len(small_array)
+    result = []
+    
+    for i in range(len(large_array) - n + 1):
+        if large_array[i:i+n] == small_array:
+            result.append(i)
+    
+    return result
+
+class Warp():
+    def __init__(self,args,):
+        self.args = args
+        self.generate_tokenizer = None
+        self.generate_model = None
+        self.logits_processor = None
+        self.reward_tokenizer = None
+        self.reward_model = None
+        self.reward_processor = None
+
+    def load_generate_model(self):
+        args = self.args
+        self.generate_tokenizer = AutoTokenizer.from_pretrained(args.generate_model_path, trust_remote_code=True)
+        self.generate_model = AutoModelForCausalLM.from_pretrained(args.generate_model_path,trust_remote_code=True).half().cuda()
+
+        if args.logits_control:
+            syntax_tree = AST(path=args.control_file,tokenizer=self.generate_tokenizer)
+            self.logits_processor = OutputControlLogitsProcessor(ast=syntax_tree, tokenizer=self.generate_tokenizer)
+
+        if re.search('<think>',self.generate_tokenizer.chat_template):
+            self.generate_tokenizer.chat_template = re.sub('<think>','',self.generate_tokenizer.chat_template)
+
+        self.none_token = '<p>none</p>'
+        self.generate_bos = self.generate_tokenizer.bos_token
+        self.generate_eos = self.generate_tokenizer.eos_token 
+
+    def load_reward_model(self,**kwargs):
+        args = self.args
+        if 'bnb_config' in kwargs.keys():
+            self.reward_model = AutoModelForCausalLM.from_pretrained(args.reward_model_path,
+                                                                     trust_remote_code=True,
+                                                                     device_map='auto', 
+                                                                     quantization_config=kwargs['bnb_config'],
+                                                                     )
+        else:
+            self.reward_model = AutoModelForCausalLM.from_pretrained(args.reward_model_path,
+                                                                     trust_remote_code=True
+                                                                     ).half().cuda()
+        self.reward_tokenizer = AutoTokenizer.from_pretrained(args.reward_model_path, trust_remote_code=True)
+        
+        if args.logits_control:
+            self.reward_processor = RewardControlLogitsProcessor(tokenizer=self.generate_tokenizer)
+
+
+        if re.search('<think>',self.reward_tokenizer.chat_template):
+            self.reward_tokenizer.chat_template = re.sub('<think>','',self.reward_tokenizer.chat_template)
+
+    @staticmethod
+    def template_to_qwen(x,bos='<|im_start|>',eos='<|im_end|>'):
+        return """system\n{system}{eos}\n{bos}user\n{query}{eos}\n{bos}assistant\n""".format(
+            bos=bos,
+            eos=eos,
+            system="You are a helpful assistant.", 
+            query=x
+        )
+    
+    @staticmethod
+    def assistant_from_template_in_response(x,bos='<|im_start|>',eos='<|im_end|>'):
+        processed_string = x.split(bos)[3].strip()
+        processed_string = processed_string.split(eos)[0].strip()
+        processed_string = re.sub('^assistant','',processed_string).strip()
+        return processed_string
+
+    @staticmethod
+    def step_from_response(x):
+        step = '</none_response>'
+        if '</think>' in x:
+            x = x.split('</think>')[-1].strip()
+        if '<p>' in x:
+            x_ = re.search('<p>.+</p>',x)
+            step = x_.group() if x_ else x
+        if '<e>' in x:
+            x_ = re.search('<e>.+</e>',x)
+            step = x_.group() if x_ else x    
+        return step
+
+    @staticmethod
+    def value_from_response(x):
+        if '<v>' in x:
+            x_ = re.search('<v>\w+</v>',x)
+            return x_.group()[3:-4] if x_ else ''
+            #return float(x_.group()[3:-4])/100 if x_ else 0
+        return ''
+
+class WarpLJP(Warp):
+    def __init__(self,args,mode='p'):
+        super().__init__(args)
+        self.mode = mode
+    
+    def processing_single(self,x,mode=''):
+        self.none_token = '<p>无</p>'
+
+        p = x['Procuratorate']
+        a = []
+        if 'd' in mode:
+            for d in x['Defence'].split('。'):
+                if len(d.strip()) > 0:
+                    a.append(d)
+        if 'f' in mode:
+            for f in x['Fact'].split('。'):
+                if len(f.strip()) > 0:
+                    a.append(f)
+
+        crime = [c['charge'] for c in x['Annotations'][0]['annotation']]
+        penalty = [c['penalty'] for c in x['Annotations'][0]['annotation']]
+        imprisonment = [c['imprisonment'] for c in x['Annotations'][0]['annotation']]
+
+        label = {'crime':';'.join(['<e>{c}罪</e>'.format(c=c) for c in crime]),
+                 'penalty':';'.join(['<e>{c}</e>'.format(c=c) for c in penalty]),
+                 'imprisonment':';'.join(['<e>{c}</e>'.format(c=c) for c in imprisonment])}
+        
+        
+        if a != []:
+            a = [_ for _ in map(lambda x_:'<p>{i}</p>'.format(i=x_) if not x_.startswith('<p>') else x_,a)]
+            return p,a,label
+        else:
+            return p,['<p>无</p>'],label
+        
+    @staticmethod
+    def prompt_to_value(x,a,bos='<|im_start|>',eos='<|im_end|>'):  
+        pmt = '根据案情描述对给出的已有推理步骤选择接受或拒绝，并在<v></v>中给出选择，例如<v>接受</v>\n案情描述:{x}\n已有推理步骤：\n{a}\n：'.format(x=x,a=a)    
+        return Warp.template_to_qwen(pmt,bos=bos,eos=eos)
+
+    @staticmethod
+    def prompt_to_crime(x,a,bos='<|im_start|>',eos='<|im_end|>'):  
+        pmt = '根据案情描述和已有步骤仅给出一个推理。如果是结论则直接输出<e></e>，例如<e>盗窃罪</e>。如果是步骤则直接输出<p></p>，例如<p>步骤1：…</p>\n案情描述:{x}\n已有推理步骤：\n{a}\n：'.format(x=x,a=a)    
+        return Warp.template_to_qwen(pmt,bos=bos,eos=eos)
+