Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,27 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+model/CNN/c1.RDS filter=lfs diff=lfs merge=lfs -text
+model/CNN/c1_test.RDS filter=lfs diff=lfs merge=lfs -text
+model/CNN/c1_train.RDS filter=lfs diff=lfs merge=lfs -text
+model/CNN/p1.RDS filter=lfs diff=lfs merge=lfs -text
+model/CNN/p1_test.RDS filter=lfs diff=lfs merge=lfs -text
+model/CNN/p1_train.RDS filter=lfs diff=lfs merge=lfs -text
+model/GAN/seq_all_encoded.RDS filter=lfs diff=lfs merge=lfs -text
+weight/CNN/model_c1/variables/variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+weight/CNN/model_p1/variables/variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+weight/GAN/GAN_model_1/variables/variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+weight/GAN/GAN_model_10/variables/variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+weight/GAN/GAN_model_11/variables/variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+weight/GAN/GAN_model_12/variables/variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+weight/GAN/GAN_model_13/variables/variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+weight/GAN/GAN_model_14/variables/variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+weight/GAN/GAN_model_15/variables/variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+weight/GAN/GAN_model_2/variables/variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+weight/GAN/GAN_model_3/variables/variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+weight/GAN/GAN_model_4/variables/variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+weight/GAN/GAN_model_5/variables/variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+weight/GAN/GAN_model_6/variables/variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+weight/GAN/GAN_model_7/variables/variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+weight/GAN/GAN_model_8/variables/variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+weight/GAN/GAN_model_9/variables/variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,437 @@
+Attribution-NonCommercial-ShareAlike 4.0 International
+
+=======================================================================
+
+Creative Commons Corporation ("Creative Commons") is not a law firm and
+does not provide legal services or legal advice. Distribution of
+Creative Commons public licenses does not create a lawyer-client or
+other relationship. Creative Commons makes its licenses and related
+information available on an "as-is" basis. Creative Commons gives no
+warranties regarding its licenses, any material licensed under their
+terms and conditions, or any related information. Creative Commons
+disclaims all liability for damages resulting from their use to the
+fullest extent possible.
+
+Using Creative Commons Public Licenses
+
+Creative Commons public licenses provide a standard set of terms and
+conditions that creators and other rights holders may use to share
+original works of authorship and other material subject to copyright
+and certain other rights specified in the public license below. The
+following considerations are for informational purposes only, are not
+exhaustive, and do not form part of our licenses.
+
+     Considerations for licensors: Our public licenses are
+     intended for use by those authorized to give the public
+     permission to use material in ways otherwise restricted by
+     copyright and certain other rights. Our licenses are
+     irrevocable. Licensors should read and understand the terms
+     and conditions of the license they choose before applying it.
+     Licensors should also secure all rights necessary before
+     applying our licenses so that the public can reuse the
+     material as expected. Licensors should clearly mark any
+     material not subject to the license. This includes other CC-
+     licensed material, or material used under an exception or
+     limitation to copyright. More considerations for licensors:
+    wiki.creativecommons.org/Considerations_for_licensors
+
+     Considerations for the public: By using one of our public
+     licenses, a licensor grants the public permission to use the
+     licensed material under specified terms and conditions. If
+     the licensor's permission is not necessary for any reason--for
+     example, because of any applicable exception or limitation to
+     copyright--then that use is not regulated by the license. Our
+     licenses grant only permissions under copyright and certain
+     other rights that a licensor has authority to grant. Use of
+     the licensed material may still be restricted for other
+     reasons, including because others have copyright or other
+     rights in the material. A licensor may make special requests,
+     such as asking that all changes be marked or described.
+     Although not required by our licenses, you are encouraged to
+     respect those requests where reasonable. More considerations
+     for the public:
+    wiki.creativecommons.org/Considerations_for_licensees
+
+=======================================================================
+
+Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International
+Public License
+
+By exercising the Licensed Rights (defined below), You accept and agree
+to be bound by the terms and conditions of this Creative Commons
+Attribution-NonCommercial-ShareAlike 4.0 International Public License
+("Public License"). To the extent this Public License may be
+interpreted as a contract, You are granted the Licensed Rights in
+consideration of Your acceptance of these terms and conditions, and the
+Licensor grants You such rights in consideration of benefits the
+Licensor receives from making the Licensed Material available under
+these terms and conditions.
+
+
+Section 1 -- Definitions.
+
+  a. Adapted Material means material subject to Copyright and Similar
+     Rights that is derived from or based upon the Licensed Material
+     and in which the Licensed Material is translated, altered,
+     arranged, transformed, or otherwise modified in a manner requiring
+     permission under the Copyright and Similar Rights held by the
+     Licensor. For purposes of this Public License, where the Licensed
+     Material is a musical work, performance, or sound recording,
+     Adapted Material is always produced where the Licensed Material is
+     synched in timed relation with a moving image.
+
+  b. Adapter's License means the license You apply to Your Copyright
+     and Similar Rights in Your contributions to Adapted Material in
+     accordance with the terms and conditions of this Public License.
+
+  c. BY-NC-SA Compatible License means a license listed at
+     creativecommons.org/compatiblelicenses, approved by Creative
+     Commons as essentially the equivalent of this Public License.
+
+  d. Copyright and Similar Rights means copyright and/or similar rights
+     closely related to copyright including, without limitation,
+     performance, broadcast, sound recording, and Sui Generis Database
+     Rights, without regard to how the rights are labeled or
+     categorized. For purposes of this Public License, the rights
+     specified in Section 2(b)(1)-(2) are not Copyright and Similar
+     Rights.
+
+  e. Effective Technological Measures means those measures that, in the
+     absence of proper authority, may not be circumvented under laws
+     fulfilling obligations under Article 11 of the WIPO Copyright
+     Treaty adopted on December 20, 1996, and/or similar international
+     agreements.
+
+  f. Exceptions and Limitations means fair use, fair dealing, and/or
+     any other exception or limitation to Copyright and Similar Rights
+     that applies to Your use of the Licensed Material.
+
+  g. License Elements means the license attributes listed in the name
+     of a Creative Commons Public License. The License Elements of this
+     Public License are Attribution, NonCommercial, and ShareAlike.
+
+  h. Licensed Material means the artistic or literary work, database,
+     or other material to which the Licensor applied this Public
+     License.
+
+  i. Licensed Rights means the rights granted to You subject to the
+     terms and conditions of this Public License, which are limited to
+     all Copyright and Similar Rights that apply to Your use of the
+     Licensed Material and that the Licensor has authority to license.
+
+  j. Licensor means the individual(s) or entity(ies) granting rights
+     under this Public License.
+
+  k. NonCommercial means not primarily intended for or directed towards
+     commercial advantage or monetary compensation. For purposes of
+     this Public License, the exchange of the Licensed Material for
+     other material subject to Copyright and Similar Rights by digital
+     file-sharing or similar means is NonCommercial provided there is
+     no payment of monetary compensation in connection with the
+     exchange.
+
+  l. Share means to provide material to the public by any means or
+     process that requires permission under the Licensed Rights, such
+     as reproduction, public display, public performance, distribution,
+     dissemination, communication, or importation, and to make material
+     available to the public including in ways that members of the
+     public may access the material from a place and at a time
+     individually chosen by them.
+
+  m. Sui Generis Database Rights means rights other than copyright
+     resulting from Directive 96/9/EC of the European Parliament and of
+     the Council of 11 March 1996 on the legal protection of databases,
+     as amended and/or succeeded, as well as other essentially
+     equivalent rights anywhere in the world.
+
+  n. You means the individual or entity exercising the Licensed Rights
+     under this Public License. Your has a corresponding meaning.
+
+
+Section 2 -- Scope.
+
+  a. License grant.
+
+       1. Subject to the terms and conditions of this Public License,
+          the Licensor hereby grants You a worldwide, royalty-free,
+          non-sublicensable, non-exclusive, irrevocable license to
+          exercise the Licensed Rights in the Licensed Material to:
+
+            a. reproduce and Share the Licensed Material, in whole or
+               in part, for NonCommercial purposes only; and
+
+            b. produce, reproduce, and Share Adapted Material for
+               NonCommercial purposes only.
+
+       2. Exceptions and Limitations. For the avoidance of doubt, where
+          Exceptions and Limitations apply to Your use, this Public
+          License does not apply, and You do not need to comply with
+          its terms and conditions.
+
+       3. Term. The term of this Public License is specified in Section
+          6(a).
+
+       4. Media and formats; technical modifications allowed. The
+          Licensor authorizes You to exercise the Licensed Rights in
+          all media and formats whether now known or hereafter created,
+          and to make technical modifications necessary to do so. The
+          Licensor waives and/or agrees not to assert any right or
+          authority to forbid You from making technical modifications
+          necessary to exercise the Licensed Rights, including
+          technical modifications necessary to circumvent Effective
+          Technological Measures. For purposes of this Public License,
+          simply making modifications authorized by this Section 2(a)
+          (4) never produces Adapted Material.
+
+       5. Downstream recipients.
+
+            a. Offer from the Licensor -- Licensed Material. Every
+               recipient of the Licensed Material automatically
+               receives an offer from the Licensor to exercise the
+               Licensed Rights under the terms and conditions of this
+               Public License.
+
+            b. Additional offer from the Licensor -- Adapted Material.
+               Every recipient of Adapted Material from You
+               automatically receives an offer from the Licensor to
+               exercise the Licensed Rights in the Adapted Material
+               under the conditions of the Adapter's License You apply.
+
+            c. No downstream restrictions. You may not offer or impose
+               any additional or different terms or conditions on, or
+               apply any Effective Technological Measures to, the
+               Licensed Material if doing so restricts exercise of the
+               Licensed Rights by any recipient of the Licensed
+               Material.
+
+       6. No endorsement. Nothing in this Public License constitutes or
+          may be construed as permission to assert or imply that You
+          are, or that Your use of the Licensed Material is, connected
+          with, or sponsored, endorsed, or granted official status by,
+          the Licensor or others designated to receive attribution as
+          provided in Section 3(a)(1)(A)(i).
+
+  b. Other rights.
+
+       1. Moral rights, such as the right of integrity, are not
+          licensed under this Public License, nor are publicity,
+          privacy, and/or other similar personality rights; however, to
+          the extent possible, the Licensor waives and/or agrees not to
+          assert any such rights held by the Licensor to the limited
+          extent necessary to allow You to exercise the Licensed
+          Rights, but not otherwise.
+
+       2. Patent and trademark rights are not licensed under this
+          Public License.
+
+       3. To the extent possible, the Licensor waives any right to
+          collect royalties from You for the exercise of the Licensed
+          Rights, whether directly or through a collecting society
+          under any voluntary or waivable statutory or compulsory
+          licensing scheme. In all other cases the Licensor expressly
+          reserves any right to collect such royalties, including when
+          the Licensed Material is used other than for NonCommercial
+          purposes.
+
+
+Section 3 -- License Conditions.
+
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+
+  a. Attribution.
+
+       1. If You Share the Licensed Material (including in modified
+          form), You must:
+
+            a. retain the following if it is supplied by the Licensor
+               with the Licensed Material:
+
+                 i. identification of the creator(s) of the Licensed
+                    Material and any others designated to receive
+                    attribution, in any reasonable manner requested by
+                    the Licensor (including by pseudonym if
+                    designated);
+
+                ii. a copyright notice;
+
+               iii. a notice that refers to this Public License;
+
+                iv. a notice that refers to the disclaimer of
+                    warranties;
+
+                 v. a URI or hyperlink to the Licensed Material to the
+                    extent reasonably practicable;
+
+            b. indicate if You modified the Licensed Material and
+               retain an indication of any previous modifications; and
+
+            c. indicate the Licensed Material is licensed under this
+               Public License, and include the text of, or the URI or
+               hyperlink to, this Public License.
+
+       2. You may satisfy the conditions in Section 3(a)(1) in any
+          reasonable manner based on the medium, means, and context in
+          which You Share the Licensed Material. For example, it may be
+          reasonable to satisfy the conditions by providing a URI or
+          hyperlink to a resource that includes the required
+          information.
+       3. If requested by the Licensor, You must remove any of the
+          information required by Section 3(a)(1)(A) to the extent
+          reasonably practicable.
+
+  b. ShareAlike.
+
+     In addition to the conditions in Section 3(a), if You Share
+     Adapted Material You produce, the following conditions also apply.
+
+       1. The Adapter's License You apply must be a Creative Commons
+          license with the same License Elements, this version or
+          later, or a BY-NC-SA Compatible License.
+
+       2. You must include the text of, or the URI or hyperlink to, the
+          Adapter's License You apply. You may satisfy this condition
+          in any reasonable manner based on the medium, means, and
+          context in which You Share Adapted Material.
+
+       3. You may not offer or impose any additional or different terms
+          or conditions on, or apply any Effective Technological
+          Measures to, Adapted Material that restrict exercise of the
+          rights granted under the Adapter's License You apply.
+
+
+Section 4 -- Sui Generis Database Rights.
+
+Where the Licensed Rights include Sui Generis Database Rights that
+apply to Your use of the Licensed Material:
+
+  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+     to extract, reuse, reproduce, and Share all or a substantial
+     portion of the contents of the database for NonCommercial purposes
+     only;
+
+  b. if You include all or a substantial portion of the database
+     contents in a database in which You have Sui Generis Database
+     Rights, then the database in which You have Sui Generis Database
+     Rights (but not its individual contents) is Adapted Material,
+     including for purposes of Section 3(b); and
+
+  c. You must comply with the conditions in Section 3(a) if You Share
+     all or a substantial portion of the contents of the database.
+
+For the avoidance of doubt, this Section 4 supplements and does not
+replace Your obligations under this Public License where the Licensed
+Rights include other Copyright and Similar Rights.
+
+
+Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+
+  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
+     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
+     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
+     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
+     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
+     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
+     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
+     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
+     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+
+  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
+     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
+     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
+     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
+     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
+     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
+     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
+     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+
+  c. The disclaimer of warranties and limitation of liability provided
+     above shall be interpreted in a manner that, to the extent
+     possible, most closely approximates an absolute disclaimer and
+     waiver of all liability.
+
+
+Section 6 -- Term and Termination.
+
+  a. This Public License applies for the term of the Copyright and
+     Similar Rights licensed here. However, if You fail to comply with
+     this Public License, then Your rights under this Public License
+     terminate automatically.
+
+  b. Where Your right to use the Licensed Material has terminated under
+     Section 6(a), it reinstates:
+
+       1. automatically as of the date the violation is cured, provided
+          it is cured within 30 days of Your discovery of the
+          violation; or
+
+       2. upon express reinstatement by the Licensor.
+
+     For the avoidance of doubt, this Section 6(b) does not affect any
+     right the Licensor may have to seek remedies for Your violations
+     of this Public License.
+
+  c. For the avoidance of doubt, the Licensor may also offer the
+     Licensed Material under separate terms or conditions or stop
+     distributing the Licensed Material at any time; however, doing so
+     will not terminate this Public License.
+
+  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+     License.
+
+
+Section 7 -- Other Terms and Conditions.
+
+  a. The Licensor shall not be bound by any additional or different
+     terms or conditions communicated by You unless expressly agreed.
+
+  b. Any arrangements, understandings, or agreements regarding the
+     Licensed Material not stated herein are separate from and
+     independent of the terms and conditions of this Public License.
+
+
+Section 8 -- Interpretation.
+
+  a. For the avoidance of doubt, this Public License does not, and
+     shall not be interpreted to, reduce, limit, restrict, or impose
+     conditions on any use of the Licensed Material that could lawfully
+     be made without permission under this Public License.
+
+  b. To the extent possible, if any provision of this Public License is
+     deemed unenforceable, it shall be automatically reformed to the
+     minimum extent necessary to make it enforceable. If the provision
+     cannot be reformed, it shall be severed from this Public License
+     without affecting the enforceability of the remaining terms and
+     conditions.
+
+  c. No term or condition of this Public License will be waived and no
+     failure to comply consented to unless expressly agreed to by the
+     Licensor.
+
+  d. Nothing in this Public License constitutes or may be interpreted
+     as a limitation upon, or waiver of, any privileges and immunities
+     that apply to the Licensor or You, including from the legal
+     processes of any jurisdiction or authority.
+
+=======================================================================
+
+Creative Commons is not a party to its public
+licenses. Notwithstanding, Creative Commons may elect to apply one of
+its public licenses to material it publishes and in those instances
+will be considered the “Licensor.” The text of the Creative Commons
+public licenses is dedicated to the public domain under the CC0 Public
+Domain Dedication. Except for the limited purpose of indicating that
+material is shared under a Creative Commons public license or as
+otherwise permitted by the Creative Commons policies published at
+creativecommons.org/policies, Creative Commons does not authorize the
+use of the trademark "Creative Commons" or any other trademark or logo
+of Creative Commons without its prior written consent including,
+without limitation, in connection with any unauthorized modifications
+to any of its public licenses or any other arrangements,
+understandings, or agreements concerning use of licensed material. For
+the avoidance of doubt, this paragraph does not form part of the
+public licenses.
+
+Creative Commons may be contacted at creativecommons.org.

README.md

@@ -0,0 +1,412 @@
+---
+license: cc-by-nc-sa-4.0
+language:
+- en
+tags:
+- OneScience
+- life-science
+- antibody
+- deep-learning
+- CNN
+- GAN
+frameworks: TensorFlow
+---
+
+<p align="center">
+  <strong>
+    <span style="font-size: 30px;">Antibody Deep Learning</span>
+  </strong>
+</p>
+
+# 模型介绍
+
+Antibody Deep Learning 是一个面向抗体 CDR3 序列分析的深度学习复现项目，主要包含两个任务：
+
+1. 使用卷积神经网络 CNN 预测 CTLA-4 和 PD-1 抗体序列是否为 binder。
+2. 使用生成对抗网络 GAN 生成面向 CTLA-4 和 PD-1 的合成 CDR3K/CDR3H 序列。
+
+原始项目以 RMarkdown 为主入口，通过 R `keras` / `reticulate` 调用 Python TensorFlow 后端。本仓库保留官方数据、官方已训练权重和原始说明，同时在 `scripts/` 目录中提供适配当前 TensorFlow/DCU 环境的等价运行脚本。
+
+论文：
+
+Predicting antibody binders and generating synthetic antibodies using deep learning
+
+https://doi.org/10.1080/19420862.2022.2069075
+
+# 模型描述
+
+本项目包含两类模型。
+
+| 模型 | 任务 | 输入 | 输出 |
+| --- | --- | --- | --- |
+| CNN | 判断 CTLA-4 / PD-1 抗体序列是否为 binder | CDR3K + CDR3H，经 padding 和 BLOSUM62 编码后为 `36 x 22 x 1` | 二分类概率，non-binder / binder |
+| GAN | 生成 CDR3 序列 | 100 维随机噪声 | `32 x 22 x 1` 的氨基酸图像，再解码为 CDR3 序列 |
+
+CNN 分别训练两个模型：
+
+| 模型路径 | 靶点 | 说明 |
+| --- | --- | --- |
+| `weight/CNN/model_c1` | CTLA-4 | 官方已训练 CNN SavedModel |
+| `weight/CNN/model_p1` | PD-1 | 官方已训练 CNN SavedModel |
+
+GAN 共 15 个生成器，对应不同 target / chain / V gene 组合：
+
+| 编号 | 官方权重路径 | 分组 |
+| --- | --- | --- |
+| 1 | `weight/GAN/GAN_model_1` | CTLA4 heavy IGHV3-33*01 |
+| 2 | `weight/GAN/GAN_model_2` | CTLA4 heavy IGHV1-18*04 |
+| 3 | `weight/GAN/GAN_model_3` | CTLA4 heavy IGHV3-20*01 |
+| 4 | `weight/GAN/GAN_model_4` | CTLA4 heavy IGHV4-39*01 |
+| 5 | `weight/GAN/GAN_model_5` | CTLA4 light IGKV3-20*01 |
+| 6 | `weight/GAN/GAN_model_6` | CTLA4 light IGKV1D-39*01 |
+| 7 | `weight/GAN/GAN_model_7` | CTLA4 light IGKV1-17*01 |
+| 8 | `weight/GAN/GAN_model_8` | CTLA4 light IGKV1-16*01 |
+| 9 | `weight/GAN/GAN_model_9` | PD1 heavy IGHV4-4*07 |
+| 10 | `weight/GAN/GAN_model_10` | PD1 heavy IGHV3-33*03 |
+| 11 | `weight/GAN/GAN_model_11` | PD1 heavy IGHV1-18*04 |
+| 12 | `weight/GAN/GAN_model_12` | PD1 light IGKV1-17*01 |
+| 13 | `weight/GAN/GAN_model_13` | PD1 light IGKV1-6*02 |
+| 14 | `weight/GAN/GAN_model_14` | PD1 light IGKV3-15*01 |
+| 15 | `weight/GAN/GAN_model_15` | PD1 light IGKV1-9*01 |
+
+# 适用场景
+
+| 场景 | 说明 |
+| --- | --- |
+| CTLA-4 / PD-1 binder 分类 | 使用仓库内置 CNN 模型，对 CDR3K + CDR3H 序列进行 BLOSUM62 编码后预测 binder / non-binder，可复现论文中的抗体结合分类任务。 |
+| 合成抗体 CDR3 序列生成 | 使用 15 个 GAN generator，按 CTLA-4 / PD-1、heavy / light chain 及 V gene 分组生成合成 CDR3 序列。 |
+| 抗体工程方法复现 | 复现论文中将抗体 CDR3 序列转为二维“抗体图像”、训练 CNN 分类器、使用 GAN 学习序列分布的核心流程。 |
+| 解释性分析和序列优化参考 | 结合原始 RMarkdown 中的模型评估、ROC 分析和 in silico mutagenesis 思路，分析影响 binder 分类的重要 CDR3 位点。 |
+
+# 使用说明
+
+## 1. OneCode 使用
+
+可通过 OneCode 在线环境体验智能化一键式 AI4S 编程：
+
+[点击体验智能化一键式 AI4S 编程](https://web-2069360198568017922-iaaj.ksai.scnet.cn:58043/home)
+
+## 2. 手动安装使用
+
+### 硬件要求
+
+- CPU 可用于数据预处理、小规模推理和连通性验证。
+- 推荐使用 GPU/DCU 进行训练和批量推理。
+- DCU 用户需要加载与当前集群匹配的 DTK 模块，并先验证 TensorFlow 基础算子可正常运行。
+
+## 安装运行环境
+
+### DCU 环境
+
+```bash
+# 请首先激活 DTK 及 CONDA
+conda create -n onescience311 python=3.11 -y
+conda activate onescience311
+# 支持uv安装
+pip install onescience[bio] -i http://mirrors.onescience.ai:3141/pypi/simple/  --trusted-host mirrors.onescience.ai
+```
+
+### 环境说明
+
+- 搭建好 OneScience 基础环境后，用户还需额外准备 R 运行环境和 R 包。安装示例：
+
+```bash
+module load R/3.6.3-gcc-7.3.1
+mkdir -p ~/R/library/3.6 ~/tmp
+export R_LIBS_USER=$HOME/R/library/3.6
+```
+
+如果集群中的 R 模块路径不是 `/public/software/apps/R-3.6.3/bin`，请先用下面命令确认实际路径，并同步替换后续命令中的 `PATH`：
+
+```bash
+which Rscript
+Rscript --version
+```
+由于 R 3.6.3 版本较老，部分 CRAN 最新包不再兼容，建议使用 CRAN 历史快照安装依赖：
+```bash
+env -i \
+HOME=$HOME \
+USER=$USER \
+PATH=/usr/bin:/bin:/public/software/apps/R-3.6.3/bin \
+R_LIBS_USER=$HOME/R/library/3.6 \
+TMPDIR=$HOME/tmp \
+Rscript -e 'options(repos=c(CRAN="https://packagemanager.posit.co/cran/2023-10-20")); install.packages(c("reticulate","dplyr","ggplot2","readr","tidyr","purrr","tibble","stringr","forcats","mltools","caret","pROC","remotes"), type="source")'
+```
+安装完成后验证 R 包可正常加载：
+
+```bash
+env -i \
+HOME=$HOME \
+USER=$USER \
+PATH=/usr/bin:/bin:/public/software/apps/R-3.6.3/bin \
+R_LIBS_USER=$HOME/R/library/3.6 \
+TMPDIR=$HOME/tmp \
+Rscript -e 'library(reticulate); library(caret); library(pROC); cat("R packages OK\n")'
+```
+后续运行 R 脚本时仍需显式传入 `R_LIBS_USER=$HOME/R/library/3.6`，否则可能出现 `there is no package called ...` 的报错。
+
+- 运行过程中遇到 TensorFlow 相关问题，可以使用平台提供的适配版 TensorFlow wheel，并加载匹配的 DTK 模块。例如：
+
+```bash
+# 1. 下载平台 TensorFlow wheel
+wget --content-disposition 'https://download.sourcefind.cn:65024/file/4/tensorflow/DAS1.8/tensorflow-2.13.1+das.opt1.dtk2604-cp311-cp311-manylinux_2_28_x86_64.whl'
+
+# 2. 安装 TensorFlow
+pip install tensorflow*
+
+# 3. 加载对应 DTK
+module load compiler/dtk/26.04
+```
+
+# 快速开始
+
+## 1. 下载模型包
+
+```bash
+hf download OneScience-Group/Antibody_deep_learning --local-dir ./Antibody_deep_learning
+cd Antibody_deep_learning
+```
+
+# 数据和权重说明
+
+## 内置数据
+
+| 路径 | 说明 |
+| --- | --- |
+| `model/CNN/all_ab_pre_post.txt` | CNN 原始输入表，包含 CDR3K、CDR3H、antigen、pre/post frequency、fold change 等信息。 |
+| `model/BLOSUM62_with_deletion.Rdata` | BLOSUM62 编码矩阵，包含 20 种氨基酸、`X` 和 gap `-`。 |
+| `model/CNN/c1.RDS` / `model/CNN/p1.RDS` | CTLA-4 / PD-1 的 train/test 划分对象。 |
+| `model/CNN/*train*.RDS` / `model/CNN/*test*.RDS` | CNN 训练和测试张量及 one-hot 标签。 |
+| `model/GAN/seq_all.RDS` | GAN 预处理 CDR3 序列，按 target/chain/V gene 分组。 |
+| `model/GAN/seq_all_encoded.RDS` | GAN BLOSUM62 编码后的训练张量列表。 |
+
+## 内置权重
+
+| 路径 | 说明 |
+| --- | --- |
+| `weight/CNN/model_c1` | 官方 CTLA-4 CNN SavedModel。 |
+| `weight/CNN/model_p1` | 官方 PD-1 CNN SavedModel。 |
+| `weight/GAN/GAN_model_1` 到 `weight/GAN/GAN_model_15` | 官方 15 个 GAN generator SavedModel。 |
+
+# 推理示例
+
+## 1. CNN 模型推理
+
+用途：加载 `weight/CNN/model_c1` 和 `weight/CNN/model_p1`，实现 CTLA-4 / PD-1 binder 分类。
+
+```bash
+env -i \
+HOME=$HOME \
+USER=$USER \
+PATH=$PATH:/public/software/apps/R-3.6.3/bin \
+LD_LIBRARY_PATH=$LD_LIBRARY_PATH \
+R_LIBS_USER=$HOME/R/library/3.6 \
+RETICULATE_PYTHON=$(which python) \
+PYTHONNOUSERSITE=1 \
+TMPDIR=$HOME/tmp \
+Rscript scripts/02_cnn_inference.R
+```
+
+输出文件：
+
+```text
+model/CNN/c1_tf218_inference_result.RDS
+model/CNN/p1_tf218_inference_result.RDS
+```
+
+## 2. GAN 模型推理
+
+用途：加载 `weight/GAN/GAN_model_1` 到 `weight/GAN/GAN_model_15`，每个模型生成 100 条 CDR3 序列。
+
+```bash
+env -i \
+HOME=$HOME \
+USER=$USER \
+PATH=$PATH:/public/software/apps/R-3.6.3/bin \
+LD_LIBRARY_PATH=$LD_LIBRARY_PATH \
+R_LIBS_USER=$HOME/R/library/3.6 \
+RETICULATE_PYTHON=$(which python) \
+PYTHONNOUSERSITE=1 \
+TMPDIR=$HOME/tmp \
+Rscript scripts/03_gan_inference.R
+```
+
+输出文件：
+
+```text
+model/GAN/gen_seq_tf218.RDS
+model/GAN/gen_seq_tf218.tsv
+```
+
+# 训练示例
+
+## 1. 数据预处理
+
+用途：生成 CNN/GAN 中间训练数据。
+
+```bash
+env -i \
+HOME=$HOME \
+USER=$USER \
+PATH=$PATH:/public/software/apps/R-3.6.3/bin \
+R_LIBS_USER=$HOME/R/library/3.6 \
+TMPDIR=$HOME/tmp \
+Rscript scripts/01_prepare_data_compat.R
+```
+
+输出包括：
+
+```text
+model/CNN/c1_train.RDS
+model/CNN/c1_test.RDS
+model/CNN/p1_train.RDS
+model/CNN/p1_test.RDS
+model/GAN/seq_all_encoded.RDS
+```
+
+## 2. CNN 训练
+
+先导出 Python 可读数据：
+
+```bash
+env -i \
+HOME=$HOME \
+USER=$USER \
+PATH=$PATH:/public/software/apps/R-3.6.3/bin \
+LD_LIBRARY_PATH=$LD_LIBRARY_PATH \
+R_LIBS_USER=$HOME/R/library/3.6 \
+RETICULATE_PYTHON=$(which python) \
+PYTHONNOUSERSITE=1 \
+TMPDIR=$HOME/tmp \
+Rscript scripts/04_export_cnn_npz.R
+```
+
+训练：
+
+```bash
+python scripts/05_train_cnn.py
+```
+
+输出：
+
+```text
+weight/CNN/model_c1_dcu
+weight/CNN/model_p1_dcu
+weight/CNN/model_c1_dcu_eval.npz
+weight/CNN/model_p1_dcu_eval.npz
+```
+
+## 3. GAN 训练
+
+先导出 Python 可读数据：
+
+```bash
+env -i \
+HOME=$HOME \
+USER=$USER \
+PATH=$PATH:/public/software/apps/R-3.6.3/bin \
+LD_LIBRARY_PATH=$LD_LIBRARY_PATH \
+R_LIBS_USER=$HOME/R/library/3.6 \
+RETICULATE_PYTHON=$(which python) \
+PYTHONNOUSERSITE=1 \
+TMPDIR=$HOME/tmp \
+Rscript scripts/06_export_gan_npz.R
+```
+
+单模型 smoke test：
+
+```bash
+python scripts/07_train_gan.py --model-id 1 --rounds 20
+```
+
+单模型完整训练：
+
+```bash
+python scripts/07_train_gan.py --model-id 1 --rounds 100
+```
+
+全量 15 个模型训练：
+
+```bash
+for i in $(seq 1 15); do
+  echo "===== training GAN model $i ====="
+  python scripts/07_train_gan.py --model-id $i --rounds 100
+done
+```
+
+输出：
+
+```text
+weight/GAN/GAN_model_1_dcu 到 weight/GAN/GAN_model_15_dcu
+weight/GAN/GAN_model_1_dcu_loss.npz 到 weight/GAN/GAN_model_15_dcu_loss.npz
+```
+
+## 4. 使用新训练 GAN 模型生成序列
+
+单模型：
+
+```bash
+python scripts/08_generate_from_trained_gan.py \
+  --model-id 1 \
+  --n-seq 100 \
+  --out-tsv model/GAN/gen_seq_trained_model_1_dcu.tsv
+```
+
+全量：
+
+```bash
+python scripts/08_generate_from_trained_gan.py \
+  --model-id 0 \
+  --n-seq 100 \
+  --out-tsv model/GAN/gen_seq_trained_all_dcu.tsv
+```
+
+生成统计：
+
+```bash
+python - <<'PY'
+import pandas as pd
+import re
+
+df = pd.read_csv("model/GAN/gen_seq_trained_all_dcu.tsv", sep="\t")
+df["length"] = df["aa"].astype(str).str.len()
+df["valid"] = df["aa"].astype(str).str.fullmatch(r"[ARNDCQEGHILKMFPSTWYV]+")
+
+summary = (
+    df.groupby(["model_id", "group"])
+      .agg(
+          n_seq=("aa", "size"),
+          n_unique=("aa", "nunique"),
+          min_len=("length", "min"),
+          median_len=("length", "median"),
+          max_len=("length", "max"),
+          valid_rate=("valid", "mean"),
+      )
+      .reset_index()
+)
+
+print(summary.to_string(index=False))
+summary.to_csv("model/GAN/gen_seq_trained_all_dcu_summary.tsv", sep="\t", index=False)
+PY
+```
+
+
+# OneScience 官方信息
+
+| 平台 | OneScience 主仓库 | Skills 仓库 |
+| --- | --- | --- |
+| Gitee | https://gitee.com/onescience-ai/onescience | https://gitee.com/onescience-ai/oneskills |
+| GitHub | https://github.com/onescience-ai/OneScience | https://github.com/onescience-ai/oneskills |
+
+# 引用与许可证
+
+- Antibody Deep Learning 原始论文：[Predicting antibody binders and generating synthetic antibodies using deep learning](https://doi.org/10.1080/19420862.2022.2069075)。
+
+- 论文信息：Yoong Wearn Lim, Adam S. Adler, David S. Johnson. *mAbs* 14(1):2069075, 2022. DOI: [10.1080/19420862.2022.2069075](https://doi.org/10.1080/19420862.2022.2069075)。
+
+- 原始代码和数据来源：[ywlim/Antibody_deep_learning](https://github.com/ywlim/Antibody_deep_learning)。论文数据可用性说明中给出了该仓库地址。
+
+- 相关源码使用 Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International(CC BY-NC-SA 4.0)，详见仓库根目录 `LICENSE`。使用、修改和再发布本项目内容时，请遵循署名、非商业使用和相同方式共享等许可要求。
+
+- 如果在科研工作中使用本项目，建议同时引用原论文以及 OneScience 相关信息。
+

conf/config.json

@@ -0,0 +1,16 @@
+{
+  "project_root": ".",
+  "data_dir": "model",
+  "weight_dir": "weight",
+  "script_dir": "scripts",
+  "cnn": {
+    "raw_table": "model/CNN/all_ab_pre_post.txt",
+    "ctla4_model": "weight/CNN/model_c1",
+    "pd1_model": "weight/CNN/model_p1"
+  },
+  "gan": {
+    "sequence_groups": "model/GAN/seq_all.RDS",
+    "encoded_groups": "model/GAN/seq_all_encoded.RDS",
+    "pretrained_model_pattern": "weight/GAN/GAN_model_{model_id}"
+  }
+}

config.json

@@ -0,0 +1,68 @@
+{
+  "model_name": "Antibody Deep Learning",
+  "framework": "TensorFlow",
+  "task": "antibody-binder-prediction-and-cdr3-generation",
+  "description": "Predict CTLA-4 and PD-1 antibody binders with CNN models and generate synthetic CDR3K/CDR3H antibody sequences with GAN models.",
+  "entry_points": {
+    "prepare_data": "scripts/01_prepare_data_compat.R",
+    "cnn_inference": "scripts/02_cnn_inference.R",
+    "gan_inference": "scripts/03_gan_inference.R",
+    "export_cnn_npz": "scripts/04_export_cnn_npz.R",
+    "train_cnn": "scripts/05_train_cnn.py",
+    "export_gan_npz": "scripts/06_export_gan_npz.R",
+    "train_gan": "scripts/07_train_gan.py",
+    "generate_from_trained_gan": "scripts/08_generate_from_trained_gan.py"
+  },
+  "source_package": "model",
+  "config": "conf/config.json",
+  "data": {
+    "blosum62": "model/BLOSUM62_with_deletion.Rdata",
+    "cnn_raw": "model/CNN/all_ab_pre_post.txt",
+    "cnn_preprocessed": [
+      "model/CNN/c1.RDS",
+      "model/CNN/c1_train.RDS",
+      "model/CNN/c1_train_y.RDS",
+      "model/CNN/c1_test.RDS",
+      "model/CNN/c1_test_y.RDS",
+      "model/CNN/p1.RDS",
+      "model/CNN/p1_train.RDS",
+      "model/CNN/p1_train_y.RDS",
+      "model/CNN/p1_test.RDS",
+      "model/CNN/p1_test_y.RDS"
+    ],
+    "gan_preprocessed": [
+      "model/GAN/seq_all.RDS",
+      "model/GAN/seq_all_encoded.RDS"
+    ]
+  },
+  "weight_dir": {
+    "cnn": [
+      "weight/CNN/model_c1",
+      "weight/CNN/model_p1"
+    ],
+    "gan": [
+      "weight/GAN/GAN_model_1",
+      "weight/GAN/GAN_model_2",
+      "weight/GAN/GAN_model_3",
+      "weight/GAN/GAN_model_4",
+      "weight/GAN/GAN_model_5",
+      "weight/GAN/GAN_model_6",
+      "weight/GAN/GAN_model_7",
+      "weight/GAN/GAN_model_8",
+      "weight/GAN/GAN_model_9",
+      "weight/GAN/GAN_model_10",
+      "weight/GAN/GAN_model_11",
+      "weight/GAN/GAN_model_12",
+      "weight/GAN/GAN_model_13",
+      "weight/GAN/GAN_model_14",
+      "weight/GAN/GAN_model_15"
+    ]
+  },
+  "runtime": {
+    "python": "3.11",
+    "tensorflow": "2.13.1 or compatible TensorFlow/DCU build",
+    "r": "3.6.3",
+    "dcu_module": "compiler/dtk/26.04"
+  },
+  "license": "CC-BY-NC-SA-4.0"
+}

model/CNN/c1.RDS

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e59c46595666a0994e3e40fbc0c80ee3b2f9122dd53a831fd12630a603497b58
+size 222118

model/CNN/c1_test.RDS

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:62a084b2334f59446ef143a66c90eeb3a750321631b01fc746f52363ff599036
+size 341118

model/CNN/c1_train.RDS

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04f38f357ba1966d503426a0df1e1c27eea0f23ca8ddffc41d57e54c815c9600
+size 1272878

model/CNN/p1.RDS

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3d827c02e36783e581fda4a0a5ec73d9208e32babb44ca09a6af634c5fe2925c
+size 229334

model/CNN/p1_test.RDS

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4db04aec944c7f994f1d0be1b40c0591cdf03741202b6bd90f174b8e3745ed06
+size 365015

model/CNN/p1_train.RDS

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7211b5dbdd331e6d4cc7fca4cc22e5f38bcf6a117487e722ed3f4ca8e8048bd9
+size 1349366

model/GAN/seq_all_encoded.RDS

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:265d5c9a2a08dc4d1e771eb85ff09da910d1efde96f4d60a914963339bb67b22
+size 123418

model/original/antibody_deep_learning.Rmd

@@ -0,0 +1,621 @@
+---
+title: "Predicting antibody binders and generating synthetic antibodies using deep learning"
+author: "Yoong Wearn Lim"
+date: "2022/02/18"
+output:
+  html_document:
+    toc: true
+    toc_float:
+      collapsed: false
+    toc_depth: 5
+    code_folding: hide
+    theme: united
+---
+
+## Goals
+
+1. To predict binder and non-binder antibodies to CTLA-4 and PD-1, using Convolutional Neural Network (CNN).
+2. To generate synthetic antibody sequences (CDR3K + CDR3H) to CTLA-4 and PD-1, using Generative Adversarial Network (GAN).
+
+## Settings
+
+Ensure that python3 and tensorflow version 2.4.0 are used.
+
+```{r global_options, message = FALSE}
+knitr::opts_chunk$set(warning=FALSE, message=FALSE)
+
+library(reticulate)
+use_virtualenv("py3-virtualenv")
+py_config()
+library(keras)
+library(tidyverse)
+library(PepTools) 
+library(mltools)
+library(caret)
+library(pROC)
+
+filter = dplyr::filter
+select = dplyr::select
+theme_set(theme_bw())
+```
+
+## Predicting binders vs. non-binders (CNN)
+
+### Prepare sequences 
+
+Here we prepare CDR3K + CDR3H amino acid sequences for both targets:
+
+1. Load all pre- and post-FACS sorted sequences.
+2. Randomize the order of the sequences.
+3. Pad CDR3K and CDR3H with "-" so all sequences have the same length.
+4. Define binders and non-binders.
+  * Binders: post/pre fold change >= 1.8, post-sort frequency >= 0.01
+  * Non-binders: post/pre fold change < 1, pre-sort frequency >= 0.01
+5. Split sequences into training and testing sets.
+
+```{r}
+all <- read_delim("CNN/all_ab_pre_post.txt", delim = "\t")
+
+# shuffle order of data frame
+set.seed(42)
+rows <- sample(nrow(all))
+all <- all[rows, ]
+
+# padding
+max_k <- max(nchar(all$CDR3K)) # 11
+max_h <- max(nchar(all$CDR3H)) # 25
+
+all$paddedh <- gsub("\\s", "-", format(all$CDR3H, width = max_h))
+all$paddedk <- gsub("\\s", "-", format(all$CDR3K, width = max_k))
+all$lengthh <- nchar(all$CDR3H)
+all$lengthk <- nchar(all$CDR3K)
+all$padded <- paste0(all$paddedk, all$paddedh)
+
+# filter for only unique sequences
+all2 <- all %>% 
+  group_by(padded) %>% 
+  top_n(1, wt = post) 
+all2 <- all2[!duplicated(all2$padded), ] 
+
+# define binders/non-binders
+all2 <- all2 %>% 
+  ungroup() %>% 
+  mutate(enriched = ifelse((fc >= 1.8 & post >= 0.01), 1,
+                           ifelse(fc < 1 & pre >= 0.01, 0, "ambi")))
+
+all2 <- filter(all2, enriched != "ambi")
+
+# split test train
+split_train_test <- function(antigenx) {
+  mini <- all2 %>% filter(antigen == antigenx)
+  set.seed(22)
+  trainIndex <- createDataPartition(mini$enriched, p = .8, 
+                                  list = FALSE, 
+                                  times = 1)
+  df_train <- mini[ trainIndex, ]
+  df_test  <- mini[-trainIndex, ]
+
+  my_list <- list(train = df_train, test = df_test)
+  return(my_list)
+}
+c1 <- split_train_test("CTLA-4")
+p1 <- split_train_test("PD-1")
+
+saveRDS(c1, file = "CNN/c1.RDS")
+saveRDS(p1, file = "CNN/p1.RDS")
+```
+
+### Visualize test train split
+
+```{r, fig.width = 5, fig.height=3}
+c1$train$type <- "Train"
+c1$test$type <- "Test"
+c1_both <- bind_rows(c1$train, c1$test)
+
+p1$train$type <- "Train"
+p1$test$type <- "Test"
+p1_both <- bind_rows(p1$train, p1$test)
+
+both <- bind_rows(c1_both, p1_both)
+count <- data.frame(table(both$antigen, both$type, both$enriched))
+names(count) <- c("antigen", "type", "binder", "freq")
+count$type <- factor(count$type, levels = c("Train", "Test"))
+
+count$binder <- as.numeric(as.character(count$binder))
+count$binder[count$binder == 0] <- "Non-binder"
+count$binder[count$binder == 1] <- "Binder"
+
+ggplot(count, aes(x = type, y = freq, fill = binder, label = freq)) +
+  facet_wrap(~ antigen, scales = "free_y") +
+  geom_col(position = "stack") +
+  geom_text(position = position_stack(vjust = .5)) +
+  theme_bw() +
+  labs(y = "# sequences")
+
+```
+
+### Encoding
+
+Encode sequences into numerical matrices (images) using BLOSUM62 scores.
+
+```{r}
+# function to encode peptides
+load(file = "BLOSUM62_with_deletion.Rdata")
+
+pep_encode_blosum <- function(pep) {
+  bl62_prob <- BLOSUM62
+  p_mat <- pep %>% pep_mat
+  n_peps <- length(pep)
+  l_peps <- nchar(pep[1])
+  l_enc <- ncol(bl62_prob)
+  o_tensor <- array(data = NA, dim = c(n_peps, l_peps, l_enc))
+  for (i in 1:n_peps) {
+      pep_i_residues <- p_mat[i, ]
+      pep_img <- bl62_prob[pep_i_residues, ]
+      o_tensor[i, , ] <- pep_img
+  }
+  return(o_tensor)
+}
+```
+
+
+```{r}
+# CTLA-4
+c1_train <- pep_encode_blosum(c1$train$padded)
+c1_test  <- pep_encode_blosum(c1$test$padded)
+
+# reshape
+c1_train <- array_reshape(c1_train, c(nrow(c1_train), ncol(c1_train), 22, 1))
+c1_test  <- array_reshape(c1_test,  c(nrow(c1_test),  ncol(c1_test),  22, 1))
+
+num_classes <- 2
+
+c1_train_y <- c1$train %>% pull(enriched) %>% array %>% keras::to_categorical(num_classes = num_classes)
+c1_test_y  <- c1$test  %>% pull(enriched) %>% array %>% keras::to_categorical(num_classes = num_classes)
+
+# PD-1
+p1_train <- pep_encode_blosum(p1$train$padded)
+p1_test  <- pep_encode_blosum(p1$test$padded)
+
+# reshape
+p1_train <- array_reshape(p1_train, c(nrow(p1_train), ncol(p1_train), 22, 1))
+p1_test  <- array_reshape(p1_test,  c(nrow(p1_test),  ncol(p1_test),  22, 1))
+
+num_classes <- 2
+
+p1_train_y <- p1$train %>% pull(enriched) %>% array %>% keras::to_categorical(num_classes = num_classes)
+p1_test_y  <- p1$test  %>% pull(enriched) %>% array %>% keras::to_categorical(num_classes = num_classes)
+ 
+saveRDS(p1_train,   file = "CNN/p1_train.RDS")
+saveRDS(p1_test,    file = "CNN/p1_test.RDS")
+saveRDS(p1_train_y, file = "CNN/p1_train_y.RDS")
+saveRDS(p1_test_y,  file = "CNN/p1_test_y.RDS")
+saveRDS(c1_train,   file = "CNN/c1_train.RDS")
+saveRDS(c1_test,    file = "CNN/c1_test.RDS")
+saveRDS(c1_train_y, file = "CNN/c1_train_y.RDS")
+saveRDS(c1_test_y,  file = "CNN/c1_test_y.RDS")
+```
+
+### CNN models 
+
+Here we build CNN models to predict binders vs. non-binders. We train the CTLA-4 model and PD-1 model separately.
+
+```{r}
+model <- keras_model_sequential() %>% 
+  layer_conv_2d(filters = 64, kernel_size = c(3, 3), 
+                activation = "relu", input_shape = c(36, 22, 1), padding = "same") %>% 
+  layer_dropout(rate = 0.5) %>% 
+  layer_max_pooling_2d(pool_size = c(2, 2), padding = "same") %>% 
+  layer_conv_2d(filters = 32, kernel_size = c(3, 4), 
+                activation = "relu", padding = "same") %>% 
+  layer_dropout(rate = 0.4) %>% 
+  layer_max_pooling_2d(pool_size = c(2, 2), padding = "same") %>% 
+  layer_conv_2d(filters = 32, kernel_size = c(4, 4), 
+                activation = "relu", padding = "same") %>% 
+  layer_dropout(rate = 0.3) %>% 
+  layer_flatten() %>% 
+  layer_dense(units = 64, activation = "relu") %>% 
+  layer_dropout(rate = 0.4) %>% 
+  layer_dense(units = 2, activation = "softmax") 
+summary(model)
+
+# duplicate model
+# note we have to use "clone_model", can't just do model_c1 <- model (this is just a pointer)
+model_c1 <- clone_model(model)
+model_p1 <- clone_model(model)
+
+# need to compile each one separately
+model_c1 %>% compile(
+  loss      = 'categorical_crossentropy',
+  optimizer = 'adam',
+  metrics   = 'accuracy'
+)
+
+model_p1 %>% compile(
+  loss      = 'categorical_crossentropy',
+  optimizer = 'adam',
+  metrics   = 'accuracy'
+)
+
+epochs           <- 30
+batch_size       <- 50
+validation_split <- 0.2 
+
+# fit models
+c1_hist <- model_c1 %>% fit(
+  c1_train, c1_train_y, 
+  epochs           = epochs,
+  batch_size       = batch_size,
+  validation_split = validation_split)
+
+p1_hist <- model_p1 %>% fit(
+  p1_train, p1_train_y, 
+  epochs           = epochs,
+  batch_size       = batch_size,
+  validation_split = validation_split)
+
+model_c1 %>% save_model_tf("CNN/model_c1")
+model_p1 %>% save_model_tf("CNN/model_p1")
+```
+
+### Prediction
+
+Now that the models are fully trained, we evaluate them using the reserved 20% test sets.
+
+#### CTLA-4 model
+
+```{r, fig.width=2.5, fig.height=2.5}
+pred_c1 <- model_c1 %>% predict_proba(c1_test) %>% as.data.frame()
+names(pred_c1) <- c("nb_prob", "b_prob")
+y_real_c1 <- c1_test_y %>% apply(1,function(x){ return( which(x==1) - 1) })  
+y_pred_c1 <- model_c1 %>% keras::predict_classes(c1_test)
+
+perf_c1 <- model_c1 %>% evaluate(c1_test, c1_test_y) 
+acc_c1 <- perf_c1[[2]] %>% round(3) * 100
+mcc_c1 <- mltools::mcc(preds = as.vector(y_pred_c1), actuals = as.vector(y_real_c1)) %>% round(2)
+
+results_c1 <- tibble(y_real  = y_real_c1, 
+                     y_pred  = y_pred_c1, 
+                     b_prob  = pred_c1$b_prob)
+
+results_c1 <- results_c1 %>% 
+  mutate(class = ifelse(y_real == 0 & y_pred == 0, "TN", 
+                                     ifelse(y_real == 0 & y_pred == 1, "FP", 
+                                            ifelse(y_real == 1 & y_pred == 1, "TP",
+                                                   ifelse(y_real == 1 & y_pred == 0, "FN", NA)))))
+
+res_c1 <- table(results_c1[, 1:2]) %>% 
+  as.data.frame() %>% 
+  mutate(y_real = as.character(y_real),
+         y_pred = as.character(y_pred))
+
+res_c1$y_real[res_c1$y_real == 0] <- "Non-binder"
+res_c1$y_pred[res_c1$y_pred == 0] <- "Non-binder"
+res_c1$y_real[res_c1$y_real == 1] <- "Binder"
+res_c1$y_pred[res_c1$y_pred == 1] <- "Binder"
+res_c1$class <- c("TN", "FN", "FP", "TP")
+
+# generate confusion matrix
+ggplot(res_c1, aes(x = y_pred, y = y_real, label = Freq, color = class)) +
+  geom_text(size = 7) +
+  geom_tile(color = "black", fill = NA) +
+  theme(axis.text.x = element_text(angle = 45, hjust = 1, vjust = 1, color = "black"),
+        axis.text.y = element_text(color = "black"),
+        axis.ticks = element_blank(), 
+        panel.grid.major = element_blank(),
+        panel.grid.minor = element_blank()) +
+  labs(y = "Measured (FACS)", x = "Predicted", title = "CTLA-4", 
+       subtitle = paste0("Accuracy=", acc_c1, "\nMCC=", mcc_c1)) +
+  scale_x_discrete(expand = c(0, 0)) +
+  scale_y_discrete(expand = c(0, 0)) +
+  guides(color = FALSE)
+
+# density plot showing binder probabilities
+ggplot(results_c1, aes(x = b_prob, color = class)) +
+  geom_density(fill = NA) +
+  theme(axis.text = element_text(color = "black"),
+        panel.grid.major = element_blank(),
+        panel.grid.minor = element_blank()) +
+  labs(y = "Density", x = "Binder probability", title = "CTLA-4", color = "Type")
+
+# roc curve
+roc_obj_c1 <- roc(y_real_c1, results_c1$b_prob)
+plot.roc(roc_obj_c1, print.auc = TRUE, main = "CTLA-4 ROC curve")
+```
+
+#### PD-1 model
+
+```{r, fig.width=2.5, fig.height=2.5}
+pred_p1 <- model_p1 %>% predict_proba(p1_test) %>% as.data.frame()
+names(pred_p1) <- c("nb_prob", "b_prob")
+y_real_p1 <- p1_test_y %>% apply(1,function(x){ return( which(x==1) - 1) })  
+y_pred_p1 <- model_p1 %>% keras::predict_classes(p1_test)
+
+perf_p1 <- model_p1 %>% evaluate(p1_test, p1_test_y) 
+acc_p1 <- perf_p1[[2]] %>% round(3) * 100
+mcc_p1 <- mltools::mcc(preds = as.vector(y_pred_p1), actuals = as.vector(y_real_p1)) %>% round(2)
+
+results_p1 <- tibble(y_real  = y_real_p1, 
+                     y_pred  = y_pred_p1, 
+                     b_prob  = pred_p1$b_prob)
+
+results_p1 <- results_p1 %>% 
+  mutate(class = ifelse(y_real == 0 & y_pred == 0, "TN", 
+                                     ifelse(y_real == 0 & y_pred == 1, "FP", 
+                                            ifelse(y_real == 1 & y_pred == 1, "TP",
+                                                   ifelse(y_real == 1 & y_pred == 0, "FN", NA)))))
+
+res_p1 <- table(results_p1[, 1:2]) %>% 
+  as.data.frame() %>% 
+  mutate(y_real = as.character(y_real),
+         y_pred = as.character(y_pred))
+
+res_p1$y_real[res_p1$y_real == 0] <- "Non-binder"
+res_p1$y_pred[res_p1$y_pred == 0] <- "Non-binder"
+res_p1$y_real[res_p1$y_real == 1] <- "Binder"
+res_p1$y_pred[res_p1$y_pred == 1] <- "Binder"
+res_p1$class <- c("TN", "FN", "FP", "TP")
+
+# generate confusion matrix
+ggplot(res_p1, aes(x = y_pred, y = y_real, label = Freq, color = class)) +
+  geom_text(size = 7) +
+  geom_tile(color = "black", fill = NA) +
+  theme(axis.text.x = element_text(angle = 45, hjust = 1, vjust = 1, color = "black"),
+        axis.text.y = element_text(color = "black"),
+        axis.ticks = element_blank(), 
+        panel.grid.major = element_blank(),
+        panel.grid.minor = element_blank()) +
+  labs(y = "Measured (FACS)", x = "Predicted", title = "PD-1", 
+       subtitle = paste0("Accuracy=", acc_p1, "\nMCC=", mcc_p1)) +
+  scale_x_discrete(expand = c(0, 0)) +
+  scale_y_discrete(expand = c(0, 0)) +
+  guides(color = FALSE)
+
+# density plot showing binder probabilities
+ggplot(results_p1, aes(x = b_prob, color = class)) +
+  geom_density(fill = NA) +
+  theme(axis.text = element_text(color = "black"),
+        panel.grid.major = element_blank(),
+        panel.grid.minor = element_blank()) +
+  labs(y = "Density", x = "Binder probability", title = "PD-1", color = "Type")
+
+# roc curve
+roc_obj_p1 <- roc(y_real_p1, results_p1$b_prob)
+plot.roc(roc_obj_p1, print.auc = TRUE, main = "PD-1 ROC curve")
+```
+
+## Generating synthetic sequences (GAN)
+
+Here we build GAN models to generate anti-CTLA-4 and anti-PD-1 CDR3 sequences. We will train a separate model for each V gene, and we will train light and heavy chain separately. In total, we will train 15 models.
+
+### Prepare sequences
+
+Previously, we annotated full length light and heavy chain sequences using [ANARCI](http://opig.stats.ox.ac.uk/webapps/newsabdab/sabpred/anarci/). 
+
+We used the AHo numbering scheme, which is based on the structural alignments of the 3D structures of the antibody variable regions. A quote from https://plueckthun.bioc.uzh.ch/antibody/Numbering/NumFrame.html:
+
+> An important difference to the numbering scheme presented here (AHo) is that in the IMGT scheme insertions and deletions "grow" unidirectionally, as in the original Chothia definition (Chothia & Lesk, 1987), while in the AHo scheme, insertions and deletions are placed symmetrically around the key position marked in yellow. Furthermore, length variations in CDR 1 and CDR 2 are represented by a single gap in IMGT and by one or two gaps in AHo.
+
+After AHo annotation, the CDR3 regions were extracted from the sequences. All sequences now have the same sequence length. 
+
+### Encoding
+
+Here we encode the pre-processed CDR3 sequences into "images".
+
+```{r}
+# pre-processed CDR3 sequences, by target, chain, and V gene
+seq_all <- readRDS(file = "GAN/seq_all.RDS")
+
+encoded <- list()
+length(encoded) <- 15
+names(encoded) <- names(seq_all)
+
+for (i in 1:15) {
+  seq_encoded <- pep_encode_blosum(seq_all[[i]])
+  # reshape
+  encoded[[i]] <- array_reshape(seq_encoded, c(nrow(seq_encoded), ncol(seq_encoded), 22, 1))
+}
+saveRDS(encoded, file = "GAN/seq_all_encoded.RDS")
+
+head(str(encoded))
+# encoded is a list with 15 items
+str(encoded[[1]])
+# num [1:307, 1:32, 1:22, 1] 0.267 0.533 0.533 0.533 0.533 ...
+```
+
+### GAN models
+
+32 positions (row), 22 possible amino acids (including X and -) (columns).
+
+```{r}
+h <- 32; w <- 22; c <- 1; l <- 100
+loss_list <- list()
+
+# 1 model for each target/chain/V gene
+# 15 models total
+for (modelx in 1:15) {
+  # generator network
+  gi <- layer_input(shape = l)
+  
+  go <- gi %>% layer_dense(units = 16 * 11 * 128) %>% 
+    layer_activation_leaky_relu() %>% 
+    layer_reshape(target_shape = c(16, 11, 128)) %>% 
+    layer_conv_2d(filters = 64, 
+                  kernel_size = c(2, 2),
+                  padding = "same") %>% 
+    layer_activation_leaky_relu() %>% 
+    layer_conv_2d_transpose(filters = 32, 
+                            kernel_size = c(2, 2),
+                            strides = 2,
+                            padding = "same") %>% 
+    layer_activation_leaky_relu() %>% 
+    layer_conv_2d(filters = 128, 
+                  kernel_size = c(5, 6), 
+                  padding = "same") %>% 
+    layer_activation_leaky_relu() %>% 
+    layer_conv_2d(filters = 1,
+                  kernel_size = c(6, 6),
+                  activation = "tanh",
+                  padding = "same")
+  g <- keras_model(gi, go)
+  summary(g)
+
+  # discriminator network
+  di <- layer_input(shape = c(h, w, c))
+  
+  do <- di %>% 
+    layer_conv_2d(filters = 96, kernel_size = 3) %>% 
+    layer_activation_leaky_relu() %>% 
+    layer_flatten() %>% 
+    layer_dropout(rate = 0.3) %>% 
+    layer_dense(units = 1, activation = "sigmoid")
+  
+  d <- keras_model(di, do)
+  
+  summary(d)
+  
+  # compile discriminator
+  d %>% compile(optimizer = "rmsprop",
+                loss = "binary_crossentropy")
+  
+  # freeze weights and compile
+  freeze_weights(d)
+  
+  gani <- layer_input(shape = l)
+  gano <- gani %>% g %>% d 
+  gan <- keras_model(gani, gano)
+  gan %>%  compile(optimizer = "rmsprop",
+                   loss = "binary_crossentropy")
+  summary(gan)
+  
+  start <- 1; dloss <- NULL; gloss <- NULL
+  
+  # use batch size = 20, train 100 rounds
+  b <- 20
+  for (i in 1:100) {
+    # random noise
+    noise <- matrix(rnorm(b * l), nrow = b, ncol = l)
+    
+    fake <- g %>% predict(noise)
+    
+    # combine real and fake images
+    stop <- start + b - 1
+    # 50 random real images
+    rowx <- sample(nrow(encoded[[modelx]]), size = b)
+    real <- encoded[[modelx]][rowx,,, , drop = FALSE] # no need to reshape since we use drop=FALSE
+ 
+    rows <- nrow(real)
+    both <- array(0, dim = c(rows * 2, dim(real)[-1]))
+    both[1:rows,,,] <- fake
+    both[(rows + 1):(rows * 2),,,] <- real
+    labels <- rbind(matrix(runif(b, 0.9, 1), nrow = b, ncol = 1),
+                    matrix(runif(b, 0, 0.1), nrow = b, ncol = 1)) # note the noise in truth labels
+  
+    # train discriminator
+    dloss[i] <- d %>% train_on_batch(both, labels)
+    
+    # train generator using gan
+    fakeAsReal <- array(runif(b, 0, 0.1), dim = c(b, 1))
+    gloss[i] <- gan %>% train_on_batch(noise, fakeAsReal)
+  }  
+  
+  # save the generator
+  save_model_tf(g, filepath = paste0("GAN/GAN_model_", modelx))
+  
+  # monitor loss
+  res <- data.frame(iteration = seq(1:100), dloss = dloss, gloss = gloss)
+  res <- res %>% 
+    gather(type, value, 2:3)
+  res$id <- modelx
+  loss_list[[modelx]] <- res
+}
+```
+
+### Generating sequences
+
+Use the fully trained GAN models to generate 100 sequences for each model.
+
+```{r}
+myseq_all <- list()
+for (j in 1:15) {
+  # load previously saved generator
+  g <- load_model_tf(paste0("GAN/GAN_model_", j))
+  
+  myseq <- list()
+  for (i in 1:100) {
+    noise <- matrix(rnorm(b * l), nrow = b, ncol = l)
+
+    # generate fake image using the generator
+    fake <- g %>% predict(noise)
+    f <- fake[1,,,]
+    dim(f) <- c(32, 22, 1)
+  
+    myseq[[i]] <- f
+  }  
+  myseq_all[[j]] <- myseq
+}
+```
+
+### Decode images 
+
+Here we decode the generated CDR3 images back into amino acid sequences.
+
+```{r}
+aa_order <- c("A", "R", "N", "D", "C", "Q", "E", "G", "H", "I", "L", "K", "M", "F", "P", "S", "T", "W", "Y", "V", "X", "-")
+
+decode_seq_cdr3 <- function(seq_list) {
+  aa_list <- list()
+  for (i in 1:length(seq_list)) {
+    peptide1 <- as.data.frame(seq_list[[i]])
+    colnames(peptide1) <- aa_order
+    
+    # remove column for amino acid X
+    # it was previously added for padding so that we have an even shape
+    peptide1 <- peptide1 %>% select(-X)
+    
+    # which amino acid has the highest score (decoding)
+    aa <- colnames(peptide1)[apply(peptide1, 1, which.max)]
+    
+    # find where the gaps are
+    gaps <- which(aa %in% "-")
+    # first and last gap in CDR3 region
+    gap_first <- gaps[gaps > 1][1]
+    gap_last <- gaps[gaps < 32]
+    gap_last <- gap_last[length(gap_last)]
+    
+    # replace spurious aa flanked by gaps in CDR3
+    aa[gap_first:gap_last] <- "-"
+    
+    aa_string <- paste(aa, collapse = "")
+    
+    # remove gaps
+    aa_string <- gsub("-", "", aa_string) 
+    
+    aa_list[[i]] <- aa_string
+  }
+  all_aa <- data.frame(aa = do.call(rbind, aa_list))
+  return(all_aa)
+}
+```
+
+```{r, fig.width = 25, fig.height=2.5}
+gen_seq <- list()
+
+for (i in 1:15) {
+  temp <- decode_seq_cdr3(myseq_all[[i]])
+  gen_seq[[i]] <- temp$aa
+}  
+
+names(gen_seq) <- names(seq_all)
+```
+
+Example generated sequences:
+
+```{r}
+for (i in 1:15) {
+  print(names(gen_seq)[i])
+  print(gen_seq[[i]][!duplicated(gen_seq[[i]])] %>% head(10))
+}  
+```
+
+

scripts/01_prepare_data_compat.R

@@ -0,0 +1,110 @@
+args <- commandArgs(trailingOnly = FALSE)
+script_arg <- grep("^--file=", args, value = TRUE)
+if (length(script_arg) > 0) {
+  script_path <- normalizePath(sub("^--file=", "", script_arg[1]))
+  setwd(normalizePath(file.path(dirname(script_path), "..")))
+}
+
+library(caret)
+
+pep_mat_local <- function(pep) {
+  do.call(rbind, strsplit(as.character(pep), split = ""))
+}
+
+one_hot <- function(y, num_classes = 2) {
+  y <- as.integer(as.character(y))
+  out <- matrix(0, nrow = length(y), ncol = num_classes)
+  out[cbind(seq_along(y), y + 1)] <- 1
+  out
+}
+
+load("model/BLOSUM62_with_deletion.Rdata")
+
+pep_encode_blosum <- function(pep) {
+  bl62_prob <- BLOSUM62
+  p_mat <- pep_mat_local(pep)
+  n_peps <- length(pep)
+  l_peps <- nchar(pep[1])
+  l_enc <- ncol(bl62_prob)
+  o_tensor <- array(data = NA, dim = c(n_peps, l_peps, l_enc))
+  for (i in 1:n_peps) {
+    pep_i_residues <- p_mat[i, ]
+    pep_img <- bl62_prob[pep_i_residues, ]
+    o_tensor[i, , ] <- pep_img
+  }
+  o_tensor
+}
+
+all <- read.delim("model/CNN/all_ab_pre_post.txt", sep = "\t", header = TRUE, stringsAsFactors = FALSE)
+
+set.seed(42)
+all <- all[sample(nrow(all)), ]
+
+max_k <- max(nchar(all$CDR3K))
+max_h <- max(nchar(all$CDR3H))
+
+all$paddedh <- gsub("\\s", "-", format(all$CDR3H, width = max_h))
+all$paddedk <- gsub("\\s", "-", format(all$CDR3K, width = max_k))
+all$lengthh <- nchar(all$CDR3H)
+all$lengthk <- nchar(all$CDR3K)
+all$padded <- paste0(all$paddedk, all$paddedh)
+
+all <- all[order(all$padded, -all$post), ]
+all2 <- all[!duplicated(all$padded), ]
+
+all2$enriched <- ifelse((all2$fc >= 1.8 & all2$post >= 0.01), 1,
+                        ifelse(all2$fc < 1 & all2$pre >= 0.01, 0, "ambi"))
+all2 <- all2[all2$enriched != "ambi", ]
+all2$enriched <- as.integer(all2$enriched)
+
+split_train_test <- function(antigenx) {
+  mini <- all2[all2$antigen == antigenx, ]
+  set.seed(22)
+  trainIndex <- createDataPartition(mini$enriched, p = .8, list = FALSE, times = 1)
+  list(train = mini[trainIndex, ], test = mini[-trainIndex, ])
+}
+
+c1 <- split_train_test("CTLA-4")
+p1 <- split_train_test("PD-1")
+
+saveRDS(c1, file = "model/CNN/c1.RDS")
+saveRDS(p1, file = "model/CNN/p1.RDS")
+
+c1_train <- pep_encode_blosum(c1$train$padded)
+c1_test  <- pep_encode_blosum(c1$test$padded)
+p1_train <- pep_encode_blosum(p1$train$padded)
+p1_test  <- pep_encode_blosum(p1$test$padded)
+
+c1_train <- array(c1_train, dim = c(dim(c1_train), 1))
+c1_test  <- array(c1_test,  dim = c(dim(c1_test), 1))
+p1_train <- array(p1_train, dim = c(dim(p1_train), 1))
+p1_test  <- array(p1_test,  dim = c(dim(p1_test), 1))
+
+c1_train_y <- one_hot(c1$train$enriched)
+c1_test_y  <- one_hot(c1$test$enriched)
+p1_train_y <- one_hot(p1$train$enriched)
+p1_test_y  <- one_hot(p1$test$enriched)
+
+saveRDS(p1_train,   file = "model/CNN/p1_train.RDS")
+saveRDS(p1_test,    file = "model/CNN/p1_test.RDS")
+saveRDS(p1_train_y, file = "model/CNN/p1_train_y.RDS")
+saveRDS(p1_test_y,  file = "model/CNN/p1_test_y.RDS")
+saveRDS(c1_train,   file = "model/CNN/c1_train.RDS")
+saveRDS(c1_test,    file = "model/CNN/c1_test.RDS")
+saveRDS(c1_train_y, file = "model/CNN/c1_train_y.RDS")
+saveRDS(c1_test_y,  file = "model/CNN/c1_test_y.RDS")
+
+seq_all <- readRDS("model/GAN/seq_all.RDS")
+encoded <- vector("list", 15)
+names(encoded) <- names(seq_all)
+
+for (i in 1:15) {
+  seq_encoded <- pep_encode_blosum(seq_all[[i]])
+  encoded[[i]] <- array(seq_encoded, dim = c(dim(seq_encoded), 1))
+}
+saveRDS(encoded, file = "model/GAN/seq_all_encoded.RDS")
+
+print("prepare data OK")
+print(dim(c1_train))
+print(dim(p1_train))
+print(names(encoded))

scripts/02_cnn_inference.R

@@ -0,0 +1,67 @@
+args <- commandArgs(trailingOnly = FALSE)
+script_arg <- grep("^--file=", args, value = TRUE)
+if (length(script_arg) > 0) {
+  script_path <- normalizePath(sub("^--file=", "", script_arg[1]))
+  setwd(normalizePath(file.path(dirname(script_path), "..")))
+}
+
+library(reticulate)
+use_python(Sys.getenv("RETICULATE_PYTHON"), required = TRUE)
+
+tf <- import("tensorflow", convert = FALSE)
+helper <- import_from_path("tf_savedmodel_helper", path = file.path(getwd(), "scripts"), convert = TRUE)
+
+mcc_score <- function(pred, real) {
+  tp <- as.numeric(sum(pred == 1 & real == 1))
+  tn <- as.numeric(sum(pred == 0 & real == 0))
+  fp <- as.numeric(sum(pred == 1 & real == 0))
+  fn <- as.numeric(sum(pred == 0 & real == 1))
+  denom <- sqrt((tp + fp) * (tp + fn) * (tn + fp) * (tn + fn))
+  if (is.na(denom) || denom == 0) return(NA_real_)
+  (tp * tn - fp * fn) / denom
+}
+
+get_input_name <- function(model_dir) {
+  model <- tf$saved_model$load(model_dir)
+  serving <- model$signatures$get("serving_default")
+  sig_text <- py_str(serving$structured_input_signature)
+  out_text <- py_str(serving$structured_outputs)
+
+  cat("\nModel:", model_dir, "\n")
+  cat("Input signature:", sig_text, "\n")
+  cat("Output signature:", out_text, "\n")
+
+  input_name <- sub(".*'([^']+)': TensorSpec.*", "\\1", sig_text)
+  cat("Input name:", input_name, "\n")
+  input_name
+}
+
+run_eval <- function(model_dir, x_file, y_file, label) {
+  x <- readRDS(x_file)
+  y <- readRDS(y_file)
+
+  input_name <- get_input_name(model_dir)
+  pred_prob <- helper$predict_saved_model(model_dir, input_name, x)
+
+  y_real <- max.col(y) - 1
+  y_pred <- max.col(pred_prob) - 1
+
+  acc <- mean(y_real == y_pred)
+  mcc <- mcc_score(y_pred, y_real)
+
+  cat("\n====", label, "====\n")
+  cat("n_test:", length(y_real), "\n")
+  cat("accuracy:", round(acc, 4), "\n")
+  cat("mcc:", round(mcc, 4), "\n")
+  print(table(real = y_real, pred = y_pred))
+
+  invisible(list(prob = pred_prob, real = y_real, pred = y_pred))
+}
+
+c1_res <- run_eval("weight/CNN/model_c1", "model/CNN/c1_test.RDS", "model/CNN/c1_test_y.RDS", "CTLA-4")
+p1_res <- run_eval("weight/CNN/model_p1", "model/CNN/p1_test.RDS", "model/CNN/p1_test_y.RDS", "PD-1")
+
+saveRDS(c1_res, "model/CNN/c1_tf218_inference_result.RDS")
+saveRDS(p1_res, "model/CNN/p1_tf218_inference_result.RDS")
+
+cat("\nCNN inference OK\n")

scripts/03_gan_inference.R

@@ -0,0 +1,103 @@
+args <- commandArgs(trailingOnly = FALSE)
+script_arg <- grep("^--file=", args, value = TRUE)
+if (length(script_arg) > 0) {
+  script_path <- normalizePath(sub("^--file=", "", script_arg[1]))
+  setwd(normalizePath(file.path(dirname(script_path), "..")))
+}
+
+library(reticulate)
+use_python(Sys.getenv("RETICULATE_PYTHON"), required = TRUE)
+
+tf <- import("tensorflow", convert = FALSE)
+helper <- import_from_path("tf_savedmodel_helper", path = file.path(getwd(), "scripts"), convert = TRUE)
+
+aa_order <- c("A", "R", "N", "D", "C", "Q", "E", "G", "H", "I",
+              "L", "K", "M", "F", "P", "S", "T", "W", "Y", "V", "X", "-")
+
+decode_seq_cdr3 <- function(seq_list) {
+  aa_list <- list()
+  for (i in seq_along(seq_list)) {
+    peptide1 <- as.data.frame(seq_list[[i]])
+    colnames(peptide1) <- aa_order
+    peptide1$X <- NULL
+
+    aa <- colnames(peptide1)[apply(peptide1, 1, which.max)]
+
+    gaps <- which(aa %in% "-")
+    if (length(gaps) > 0) {
+      gap_first <- gaps[gaps > 1][1]
+      gap_last_candidates <- gaps[gaps < 32]
+      gap_last <- gap_last_candidates[length(gap_last_candidates)]
+      if (!is.na(gap_first) && !is.na(gap_last) && gap_first <= gap_last) {
+        aa[gap_first:gap_last] <- "-"
+      }
+    }
+
+    aa_string <- paste(aa, collapse = "")
+    aa_string <- gsub("-", "", aa_string)
+    aa_list[[i]] <- aa_string
+  }
+  data.frame(aa = unlist(aa_list), stringsAsFactors = FALSE)
+}
+
+get_input_name <- function(model_dir) {
+  model <- tf$saved_model$load(model_dir)
+  serving <- model$signatures$get("serving_default")
+  sig_text <- py_str(serving$structured_input_signature)
+  out_text <- py_str(serving$structured_outputs)
+
+  cat("\nModel:", model_dir, "\n")
+  cat("Input signature:", sig_text, "\n")
+  cat("Output signature:", out_text, "\n")
+
+  input_name <- sub(".*'([^']+)': TensorSpec.*", "\\1", sig_text)
+  cat("Input name:", input_name, "\n")
+  input_name
+}
+
+generate_model <- function(model_id, n_seq = 100, batch_size = 20, latent_dim = 100) {
+  model_dir <- paste0("weight/GAN/GAN_model_", model_id)
+  input_name <- get_input_name(model_dir)
+
+  seq_list <- list()
+  k <- 1
+
+  set.seed(1000 + model_id)
+
+  while (length(seq_list) < n_seq) {
+    noise <- matrix(rnorm(batch_size * latent_dim), nrow = batch_size, ncol = latent_dim)
+    fake <- helper$predict_saved_model(model_dir, input_name, noise)
+
+    for (i in seq_len(dim(fake)[1])) {
+      f <- fake[i,,,]
+      dim(f) <- c(32, 22, 1)
+      seq_list[[k]] <- f
+      k <- k + 1
+      if (length(seq_list) >= n_seq) break
+    }
+  }
+
+  decode_seq_cdr3(seq_list)
+}
+
+seq_all <- readRDS("model/GAN/seq_all.RDS")
+gen_seq <- list()
+
+for (i in 1:15) {
+  cat("\nGenerating model", i, names(seq_all)[i], "\n")
+  temp <- generate_model(i, n_seq = 100)
+  gen_seq[[i]] <- temp$aa
+  cat("unique first 10:\n")
+  print(head(unique(gen_seq[[i]]), 10))
+}
+
+names(gen_seq) <- names(seq_all)
+saveRDS(gen_seq, "model/GAN/gen_seq_tf218.RDS")
+
+out <- data.frame()
+ for (i in seq_along(gen_seq)) {
+  out <- rbind(out, data.frame(model_id = i, group = names(gen_seq)[i], aa = gen_seq[[i]], stringsAsFactors = FALSE))
+}
+write.table(out, "model/GAN/gen_seq_tf218.tsv", sep = "\t", quote = FALSE, row.names = FALSE)
+
+cat("\nGAN generation OK\n")

scripts/04_export_cnn_npz.R

@@ -0,0 +1,25 @@
+args <- commandArgs(trailingOnly = FALSE)
+script_arg <- grep("^--file=", args, value = TRUE)
+if (length(script_arg) > 0) {
+  script_path <- normalizePath(sub("^--file=", "", script_arg[1]))
+  setwd(normalizePath(file.path(dirname(script_path), "..")))
+}
+
+library(reticulate)
+use_python(Sys.getenv("RETICULATE_PYTHON"), required = TRUE)
+np <- import("numpy", convert = FALSE)
+
+save_npz <- function(out_file, x_train, y_train, x_test, y_test) {
+  np$savez_compressed(
+    out_file,
+    x_train = np$array(readRDS(x_train), dtype = "float32"),
+    y_train = np$array(readRDS(y_train), dtype = "float32"),
+    x_test  = np$array(readRDS(x_test),  dtype = "float32"),
+    y_test  = np$array(readRDS(y_test),  dtype = "float32")
+  )
+}
+
+save_npz("model/CNN/c1_data.npz", "model/CNN/c1_train.RDS", "model/CNN/c1_train_y.RDS", "model/CNN/c1_test.RDS", "model/CNN/c1_test_y.RDS")
+save_npz("model/CNN/p1_data.npz", "model/CNN/p1_train.RDS", "model/CNN/p1_train_y.RDS", "model/CNN/p1_test.RDS", "model/CNN/p1_test_y.RDS")
+
+cat("export cnn npz OK\n")

scripts/05_train_cnn.py

@@ -0,0 +1,83 @@
+import os
+import numpy as np
+import tensorflow as tf
+
+os.environ.setdefault("TF_FORCE_GPU_ALLOW_GROWTH", "true")
+
+def build_model():
+    model = tf.keras.Sequential([
+        tf.keras.layers.Conv2D(64, (3, 3), activation="relu", input_shape=(36, 22, 1), padding="same"),
+        tf.keras.layers.Dropout(0.5),
+        tf.keras.layers.MaxPooling2D((2, 2), padding="same"),
+        tf.keras.layers.Conv2D(32, (3, 4), activation="relu", padding="same"),
+        tf.keras.layers.Dropout(0.4),
+        tf.keras.layers.MaxPooling2D((2, 2), padding="same"),
+        tf.keras.layers.Conv2D(32, (4, 4), activation="relu", padding="same"),
+        tf.keras.layers.Dropout(0.3),
+        tf.keras.layers.Flatten(),
+        tf.keras.layers.Dense(64, activation="relu"),
+        tf.keras.layers.Dropout(0.4),
+        tf.keras.layers.Dense(2, activation="softmax"),
+    ])
+    model.compile(
+        loss="categorical_crossentropy",
+        optimizer="adam",
+        metrics=["accuracy"],
+    )
+    return model
+
+def mcc_score(y_pred, y_real):
+    y_pred = y_pred.astype(int)
+    y_real = y_real.astype(int)
+    tp = float(np.sum((y_pred == 1) & (y_real == 1)))
+    tn = float(np.sum((y_pred == 0) & (y_real == 0)))
+    fp = float(np.sum((y_pred == 1) & (y_real == 0)))
+    fn = float(np.sum((y_pred == 0) & (y_real == 1)))
+    denom = np.sqrt((tp + fp) * (tp + fn) * (tn + fp) * (tn + fn))
+    return np.nan if denom == 0 else (tp * tn - fp * fn) / denom
+
+def train_one(name, data_file, out_dir):
+    print(f"\n==== training {name} ====")
+    data = np.load(data_file)
+    x_train = data["x_train"].astype("float32")
+    y_train = data["y_train"].astype("float32")
+    x_test = data["x_test"].astype("float32")
+    y_test = data["y_test"].astype("float32")
+
+    print("x_train", x_train.shape, "y_train", y_train.shape)
+    print("x_test ", x_test.shape, "y_test ", y_test.shape)
+    print("GPUs:", tf.config.list_physical_devices("GPU"))
+
+    with tf.device("/GPU:0"):
+        model = build_model()
+        model.fit(
+            x_train,
+            y_train,
+            epochs=30,
+            batch_size=50,
+            validation_split=0.2,
+            verbose=2,
+        )
+        prob = model.predict(x_test, batch_size=128, verbose=0)
+
+    y_real = np.argmax(y_test, axis=1)
+    y_pred = np.argmax(prob, axis=1)
+    acc = float(np.mean(y_real == y_pred))
+    mcc = float(mcc_score(y_pred, y_real))
+
+    print(f"\n{name} accuracy: {acc:.4f}")
+    print(f"{name} mcc: {mcc:.4f}")
+    print("confusion matrix rows=real cols=pred")
+    cm = np.zeros((2, 2), dtype=int)
+    for r, p in zip(y_real, y_pred):
+        cm[r, p] += 1
+    print(cm)
+
+    model.save(out_dir)
+    #model.save(out_dir + ".keras")
+    np.savez_compressed(out_dir + "_eval.npz", prob=prob, y_real=y_real, y_pred=y_pred, cm=cm, acc=acc, mcc=mcc)
+    print("saved", out_dir)
+
+train_one("CTLA-4", "model/CNN/c1_data.npz", "weight/CNN/model_c1_dcu")
+train_one("PD-1", "model/CNN/p1_data.npz", "weight/CNN/model_p1_dcu")
+print("\nCNN DCU training OK")

scripts/06_export_gan_npz.R

@@ -0,0 +1,25 @@
+args <- commandArgs(trailingOnly = FALSE)
+script_arg <- grep("^--file=", args, value = TRUE)
+if (length(script_arg) > 0) {
+  script_path <- normalizePath(sub("^--file=", "", script_arg[1]))
+  setwd(normalizePath(file.path(dirname(script_path), "..")))
+}
+
+library(reticulate)
+use_python(Sys.getenv("RETICULATE_PYTHON"), required = TRUE)
+np <- import("numpy", convert = FALSE)
+
+encoded <- readRDS("model/GAN/seq_all_encoded.RDS")
+names_encoded <- names(encoded)
+
+for (i in seq_along(encoded)) {
+  out_file <- sprintf("model/GAN/seq_encoded_%02d.npz", i)
+  np$savez_compressed(
+    out_file,
+    x = np$array(encoded[[i]], dtype = "float32"),
+    name = names_encoded[[i]]
+  )
+  cat("saved", out_file, names_encoded[[i]], dim(encoded[[i]]), "\n")
+}
+
+cat("export GAN npz OK\n")

scripts/07_train_gan.py

@@ -0,0 +1,130 @@
+import argparse
+import os
+import numpy as np
+import tensorflow as tf
+
+os.environ.setdefault("TF_FORCE_GPU_ALLOW_GROWTH", "true")
+
+def build_generator(latent_dim=100):
+    inputs = tf.keras.Input(shape=(latent_dim,))
+    x = tf.keras.layers.Dense(16 * 11 * 128)(inputs)
+    x = tf.keras.layers.LeakyReLU()(x)
+    x = tf.keras.layers.Reshape((16, 11, 128))(x)
+    x = tf.keras.layers.Conv2D(64, (2, 2), padding="same")(x)
+    x = tf.keras.layers.LeakyReLU()(x)
+    x = tf.keras.layers.Conv2DTranspose(32, (2, 2), strides=2, padding="same")(x)
+    x = tf.keras.layers.LeakyReLU()(x)
+    x = tf.keras.layers.Conv2D(128, (5, 6), padding="same")(x)
+    x = tf.keras.layers.LeakyReLU()(x)
+    outputs = tf.keras.layers.Conv2D(1, (6, 6), activation="tanh", padding="same")(x)
+    return tf.keras.Model(inputs, outputs, name="generator")
+
+def build_discriminator():
+    inputs = tf.keras.Input(shape=(32, 22, 1))
+    x = tf.keras.layers.Conv2D(96, 3)(inputs)
+    x = tf.keras.layers.LeakyReLU()(x)
+    x = tf.keras.layers.Flatten()(x)
+    x = tf.keras.layers.Dropout(0.3)(x)
+    outputs = tf.keras.layers.Dense(1, activation="sigmoid")(x)
+    return tf.keras.Model(inputs, outputs, name="discriminator")
+
+def train_gan(model_id, rounds=100, batch_size=20, latent_dim=100, seed=42):
+    np.random.seed(seed + model_id)
+    tf.random.set_seed(seed + model_id)
+
+    data_file = f"model/GAN/seq_encoded_{model_id:02d}.npz"
+    data = np.load(data_file, allow_pickle=True)
+    real_data = data["x"].astype("float32")
+    group_name = str(data["name"])
+
+    print(f"\n==== GAN model {model_id}: {group_name} ====")
+    print("real_data:", real_data.shape)
+    print("GPUs:", tf.config.list_physical_devices("GPU"))
+
+    with tf.device("/GPU:0"):
+        generator = build_generator(latent_dim)
+        discriminator = build_discriminator()
+
+        discriminator.compile(
+            optimizer=tf.keras.optimizers.RMSprop(),
+            loss="binary_crossentropy",
+        )
+
+        discriminator.trainable = False
+        gan_input = tf.keras.Input(shape=(latent_dim,))
+        gan_output = discriminator(generator(gan_input))
+        gan = tf.keras.Model(gan_input, gan_output, name="gan")
+        gan.compile(
+            optimizer=tf.keras.optimizers.RMSprop(),
+            loss="binary_crossentropy",
+        )
+
+        dloss = []
+        gloss = []
+
+        for step in range(1, rounds + 1):
+            noise = np.random.normal(size=(batch_size, latent_dim)).astype("float32")
+            fake = generator.predict(noise, verbose=0)
+
+            idx = np.random.choice(real_data.shape[0], size=batch_size, replace=True)
+            real = real_data[idx]
+
+            both = np.concatenate([fake, real], axis=0).astype("float32")
+
+            labels_fake = np.random.uniform(0.9, 1.0, size=(batch_size, 1)).astype("float32")
+            labels_real = np.random.uniform(0.0, 0.1, size=(batch_size, 1)).astype("float32")
+            labels = np.concatenate([labels_fake, labels_real], axis=0)
+
+            discriminator.trainable = True
+            d_loss = discriminator.train_on_batch(both, labels)
+
+            noise = np.random.normal(size=(batch_size, latent_dim)).astype("float32")
+            fake_as_real = np.random.uniform(0.0, 0.1, size=(batch_size, 1)).astype("float32")
+
+            discriminator.trainable = False
+            g_loss = gan.train_on_batch(noise, fake_as_real)
+
+            dloss.append(float(d_loss))
+            gloss.append(float(g_loss))
+
+            if step == 1 or step % 10 == 0 or step == rounds:
+                print(f"step {step:03d}/{rounds} dloss={dloss[-1]:.6f} gloss={gloss[-1]:.6f}")
+
+    out_dir = f"weight/GAN/GAN_model_{model_id}_dcu"
+    generator.save(out_dir)
+    #generator.save(out_dir + ".keras")
+
+    loss_file = f"weight/GAN/GAN_model_{model_id}_dcu_loss.npz"
+    np.savez_compressed(
+        loss_file,
+        dloss=np.array(dloss, dtype="float32"),
+        gloss=np.array(gloss, dtype="float32"),
+        model_id=model_id,
+        group_name=group_name,
+    )
+
+    print("saved generator:", out_dir)
+    print("saved loss:", loss_file)
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model-id", type=int, required=True, help="GAN model id, 1-15")
+    parser.add_argument("--rounds", type=int, default=100)
+    parser.add_argument("--batch-size", type=int, default=20)
+    parser.add_argument("--latent-dim", type=int, default=100)
+    parser.add_argument("--seed", type=int, default=42)
+    args = parser.parse_args()
+
+    if args.model_id < 1 or args.model_id > 15:
+        raise ValueError("--model-id must be between 1 and 15")
+
+    train_gan(
+        model_id=args.model_id,
+        rounds=args.rounds,
+        batch_size=args.batch_size,
+        latent_dim=args.latent_dim,
+        seed=args.seed,
+    )
+
+if __name__ == "__main__":
+    main()

scripts/08_generate_from_trained_gan.py

@@ -0,0 +1,138 @@
+import argparse
+import os
+from pathlib import Path
+
+import numpy as np
+import tensorflow as tf
+
+os.environ.setdefault("TF_FORCE_GPU_ALLOW_GROWTH", "true")
+
+AA_ORDER = ["A", "R", "N", "D", "C", "Q", "E", "G", "H", "I",
+            "L", "K", "M", "F", "P", "S", "T", "W", "Y", "V", "X", "-"]
+
+def decode_one(img):
+    arr = np.asarray(img)
+    arr = arr.reshape(32, 22)
+
+    # remove X column, same as README
+    arr_no_x = np.delete(arr, 20, axis=1)
+    aa_no_x = AA_ORDER[:20] + ["-"]
+
+    aa_idx = np.argmax(arr_no_x, axis=1)
+    aa = np.array([aa_no_x[i] for i in aa_idx], dtype=object)
+
+    gaps = np.where(aa == "-")[0] + 1  # use 1-based position to mimic R logic
+    if len(gaps) > 0:
+        gap_first_candidates = gaps[gaps > 1]
+        gap_last_candidates = gaps[gaps < 32]
+        if len(gap_first_candidates) > 0 and len(gap_last_candidates) > 0:
+            gap_first = int(gap_first_candidates[0])
+            gap_last = int(gap_last_candidates[-1])
+            if gap_first <= gap_last:
+                aa[(gap_first - 1):gap_last] = "-"
+
+    seq = "".join(aa.tolist()).replace("-", "")
+    return seq
+
+def generate_one(model_id, n_seq=100, batch_size=20, latent_dim=100, seed=2026):
+    #model_dir = Path(f"weight/GAN/GAN_model_{model_id}_dcu.keras")
+    model_dir = Path(f"weight/GAN/GAN_model_{model_id}_dcu")
+    if not model_dir.exists():
+        raise FileNotFoundError(f"Missing trained model: {model_dir}")
+
+    np.random.seed(seed + model_id)
+    tf.random.set_seed(seed + model_id)
+
+    model = tf.keras.models.load_model(str(model_dir), compile=False)
+
+    seqs = []
+    with tf.device("/GPU:0"):
+        while len(seqs) < n_seq:
+            noise = np.random.normal(size=(batch_size, latent_dim)).astype("float32")
+            fake = model(noise, training=False).numpy()
+
+            for i in range(fake.shape[0]):
+                seqs.append(decode_one(fake[i]))
+                if len(seqs) >= n_seq:
+                    break
+
+    return seqs
+
+def load_group_names():
+    names = []
+    for i in range(1, 16):
+        f = Path(f"model/GAN/seq_encoded_{i:02d}.npz")
+        if f.exists():
+            d = np.load(f, allow_pickle=True)
+            names.append(str(d["name"]))
+        else:
+            names.append(f"GAN_model_{i}")
+    return names
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model-id", type=int, default=0, help="0 means all models; otherwise 1-15")
+    parser.add_argument("--n-seq", type=int, default=100)
+    parser.add_argument("--batch-size", type=int, default=20)
+    parser.add_argument("--latent-dim", type=int, default=100)
+    parser.add_argument("--seed", type=int, default=2026)
+    parser.add_argument("--out-tsv", default="model/GAN/gen_seq_trained_dcu.tsv")
+    args = parser.parse_args()
+
+    group_names = load_group_names()
+
+    if args.model_id == 0:
+        model_ids = range(1, 16)
+    else:
+        if args.model_id < 1 or args.model_id > 15:
+            raise ValueError("--model-id must be 0 or 1-15")
+        model_ids = [args.model_id]
+
+    rows = []
+    all_seqs = {}
+
+    for model_id in model_ids:
+        group = group_names[model_id - 1]
+        print(f"\nGenerating from trained model {model_id}: {group}")
+        seqs = generate_one(
+            model_id=model_id,
+            n_seq=args.n_seq,
+            batch_size=args.batch_size,
+            latent_dim=args.latent_dim,
+            seed=args.seed,
+        )
+        all_seqs[model_id] = seqs
+
+        unique = []
+        seen = set()
+        for s in seqs:
+            if s not in seen:
+                unique.append(s)
+                seen.add(s)
+
+        print("unique first 10:")
+        print(unique[:10])
+        print("n_seq:", len(seqs), "n_unique:", len(unique))
+
+        for rank, seq in enumerate(seqs, start=1):
+            rows.append((model_id, group, rank, seq, len(seq)))
+
+    out_path = Path(args.out_tsv)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+
+    with out_path.open("w") as f:
+        f.write("model_id\tgroup\trank\taa\tlength\n")
+        for row in rows:
+            f.write("\t".join(map(str, row)) + "\n")
+
+    np.savez_compressed(
+        str(out_path).replace(".tsv", ".npz"),
+        **{f"model_{k:02d}": np.array(v, dtype=object) for k, v in all_seqs.items()}
+    )
+
+    print("\nsaved:", out_path)
+    print("saved:", str(out_path).replace(".tsv", ".npz"))
+    print("GAN trained-model generation OK")
+
+if __name__ == "__main__":
+    main()

scripts/tf_savedmodel_helper.py

@@ -0,0 +1,11 @@
+import numpy as np
+import tensorflow as tf
+
+def predict_saved_model(model_dir, input_name, x):
+    model = tf.saved_model.load(model_dir)
+    serving = model.signatures["serving_default"]
+    x = np.asarray(x, dtype=np.float32)
+    with tf.device("/GPU:0"):
+        out = serving(**{input_name: tf.constant(x)})
+    first_key = list(out.keys())[0]
+    return out[first_key].numpy()

weight/CNN/model_c1/saved_model.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3d523365865feb68260c10c78ae9c196aab6149349a97cd7113063aa9f756e3b
+size 206837

weight/CNN/model_c1/variables/variables.data-00000-of-00001

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:94e131857bee132a6e8b31363fc04c74c79fc400bbdd2e42b123fedb1beb7c28
+size 1838457

weight/CNN/model_p1/saved_model.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea02f85ba2a2e00306ae2f963523d7fd86e2dd2eae30a252cb634277ce5ae456
+size 206837

weight/CNN/model_p1/variables/variables.data-00000-of-00001

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8f0b16d2906c45128e91dcfadb97a20f21a027d951c18f5f743fedfce32c3caf
+size 1838457

weight/GAN/GAN_model_1/saved_model.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c95b33f2869991bff6b84ae7f6911b59b387341d57b33486c28581396396b680
+size 154394

weight/GAN/GAN_model_1/variables/variables.data-00000-of-00001

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6dfd9c7f6e57302f30ba8fe94514b6fd2e40ff5a26464a5537ed67841fc19630
+size 9780733

weight/GAN/GAN_model_10/saved_model.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e41616ca6f4927130e8587c3392d9f1e2281c036ddf54b1fed7f5dc4499db57a
+size 157107

weight/GAN/GAN_model_10/variables/variables.data-00000-of-00001

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c496bb4b9de209573c69ed06db5382dd34d6155e2cea95d7eb82b5be1e815edf
+size 9780745

weight/GAN/GAN_model_11/saved_model.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:68d34852fdb40df16545d2f84f2373ff2fcaac12683096dc85fab54afd682f05
+size 157508

weight/GAN/GAN_model_11/variables/variables.data-00000-of-00001

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3efcb4b884e77bcd0ee49d804b344092b6be0a2655e9eee664f87ab3a8fc628c
+size 9780747

weight/GAN/GAN_model_12/saved_model.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c4de0b798101b76a383cb444e04e6ce64ef493cdd6fb683b87242241618c2e58
+size 157508

weight/GAN/GAN_model_12/variables/variables.data-00000-of-00001

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:133ad21b0d2136d9f17d0afcf9b1a53483906f7744ef3b44a61db11ba603373b
+size 9780747

weight/GAN/GAN_model_13/saved_model.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c6faceceafc4015345b43e9b2fdee255b0a1ae5344cdca0e92318f989531e501
+size 157508

weight/GAN/GAN_model_13/variables/variables.data-00000-of-00001

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b8dbe2acae91269808165419e97b8916ac1764adfcab2cfdf81e30473bf5b3f3
+size 9780747