法律状态公告日
法律状态信息
法律状态
2020-04-10
专利权的转移 IPC(主分类):G06F19/22 登记生效日:20200323 变更前: 变更后: 申请日:20081009
专利申请权、专利权的转移
2013-05-22
授权
授权
2010-10-20
实质审查的生效 IPC(主分类):G06F19/00 申请日:20081009
实质审查的生效
2010-09-01
公开
公开
技术领域
本发明涉及用于诸如植物等异源生物体中表达的合成基因的设计方法，包括计算机实现的方法，也包括用于执行本发明方法的计算机系统。
技术背景
如植物细胞的异源宿主中的外源基因表达已很难，并经常无法获得产品的可检测的表达(Fischhoff等(1987)生物/技术5：807-813；Vaeck等(1987)自然328：33-37)。对贫乏表达的解释包括加工位点的偶然存在，导致在转基因宿主细胞中非功能mRNA转录物；相较于原始宿主在植物中不同的密码子使用；以及在基因序列的GC含量和由此产生的初级RNA转录物中的不同。沿着双螺旋结构的双碱基组成DNA结构。众所周知，不同生物体的总DNA具有四种核苷酸：腺嘌呤(A)、胸苷(T)、鸟苷(G)以及胞苷(C)的不同分布。在DNA螺旋结构中，腺嘌呤和胸苷通过氢键结合形成一个“碱基对”(“AT碱基对”)。同样，鸟苷仅和胞苷形成碱基对(“GC碱基对”)。这种AT碱基对与GC碱基对的比例通常被称为“GC含量”，其为由GC碱基对(相对于AT碱基对)构成的总碱基对的百分比。同样，“AT含量”是指AT碱基对构成的碱基对的百分比。GC含量不仅在不同生物体中不同，而且在基因组的DNA不同区域中不同，甚至在例如植物基因的一个基因的不同区域中不同。植物内含子有大约70％AT(30％ GC)含量，而外显子有大约50％AT(50％ GC)含量(Wiebauer等(1988)Mol.Cell Biol.8：2042-2051)。
由于在植物中表达苏云金芽孢杆菌(Bt)杀虫剂蛋白的困难性，各种在转录植物中较高水平表达的合成基因已被设计。Adang等(美国专利号5380831，6015891)描述了设计合成Bt杀虫蛋白以在植物中具有增强的表达，通过修饰基因以包含高水平表达的植物基因优选的密码子进行所述设计。根据在被高水平表达的植物基因中所用的密码子使用分布频率来选择密码子使用。Adang等(美国专利号5567600)进一步描述了类似的方法，其中修饰包括减少在植物多腺苷酸化信号之间区域中的密码子位置Ⅱ和Ⅲ中具有GC的密码子数量。备选地，修饰可导致较少地发生序列AATGAA(SEQ ID NO：1)。
Fischhoff等(美国专利号5500365)揭示了修饰的Bt基因，其移除了植物多腺苷酸化序列以及ATTTA(SEQ ID NO：2)序列。Koziel等(美国专利号6320100)揭示了为在植物中优化表达而选择的合成Bt杀虫蛋白，其使用的密码子在玉米中最频繁地编码每一氨基酸，并具有60％的GC含量。
发明概述
提供了产生编码感兴趣的多肽的合成核苷酸序列的方法。这些方法如下产生优化的合成基因序列：计算在DNA序列数据库中的连续短核苷酸区段的发生概率，并且然后使用这些概率通过用高概率序列代替在候选转基因中的低概率核苷酸序列来产生合成序列。这优选不改变编码蛋白质的氨基酸序列来完成。重要地是，此统计方法能够产生转基因，其经优化在目标生物体表达而不需要在目标生物体中的加工位点或其他表达决定因素的特定知识。
这些方法包括(1)序列数据库的开发；(2)选择一连续核苷酸长度(“N长度”)作为优化(“N长度寡核苷酸”)的基础；(3)组织序列数据库作为N长度寡聚物序列集合；(4)选择一输入序列；(5)为输入序列开发沉默NLSs(“SNLS”)集合；以及(6)在SNLS的选择中优化以生成一被优化的基因序列。
这些方法可以备选地或另外包括移除不期望的可读框，和/或修饰感兴趣的核苷酸序列以移除不期望的短的共有核苷酸序列，和/或所得优化基因获得期望的GC含量，而不考虑密码子使用。
本发明的方法可用于产生在生物体、特别是植物和细菌中理想表达的核苷酸序列以提供杀虫或除草剂耐抗性活性。这些生物体被期望用于农业目的。本发明的方法可用于产生具有杀虫或除草剂抗性活性的改变的或改进的蛋白质，或者用于检测在产品或生物体中杀虫或除草剂抗性蛋白质或氨基酸的存在。
附图说明
图1所示为NLRs，NLS以及delta表之间关系的图示。此图中的A，B，C，D以及E代表了在长度为5(N＝5)的核苷酸区域中的假定位置。此图示出可为该NLR生成的NLSs的子集。因此，对于所有长度为5的NLRs，有4’个可能的NLSs(在位置A处为A，T，G，或C；在位置B处为A，T，G，或C；等等)。
图2所示为NLSs的确定的图例。
发明详述
合成基因设计的先前方法通常分为两类。第一类使用诸如多聚腺苷酸化信号的加工信号的特定知识来设计在目标生物体具有更高表达概率的转基因(例如Fischhoff等)。此策略仅被应用于这种加工信号的特定实验性知识是可用的情况下。另外，被表达基因的加工决定因素的不完整的知识会导致转基因的不当修饰，导致目标生物体中较少或没有表达。第二类方法完全依赖于密码子偏倚和/或GC含量修正以改进转基因表达(例如Koziel等，Adang等)，而不管高级DNA序列决定因素(如ATTTA，AATGAA)的重要作用的充分证据。
本发明描述了设计编码感兴趣的多肽的合成核苷酸序列的方法。所述方法包括(1)组织一序列数据库作为N长度寡聚物序列集(“NLSs”)的集合；(2)通过确定和编译所有可能NLSs群体间的每一NLS的被观察到的概率生成一NLS统计表；(3)为感兴趣的序列产生NLRs集合；(4)确定没有破坏可读框的NLSs(“沉默NLSs”，或者“SNLS”)的集合；以及(5)优化在SLNS集合之间的选择以生成被优化的核苷酸序列。
在本发明的另一方面，分析和调整感兴趣的核苷酸序列以移除下面两者或其中之一：(1)非期望的可读框或者(2)非期望的短DNA元件。“非期望的ORF”是不同于亲本序列且通过用本发明的方法修饰序列而来的ORF。“非期望的短DNA元件”包括引入目标生物体非理想表达结构的DNA序列。短DNA元件的示例在本文别处讨论。
这些方法可用于优化任何生物体、特别是植物中的异源基因的表达。此方法生成合成基因，其组成与目标数据库的相似。这些合成基因可被用于，例如在生物体、尤其是在植物或植物细胞中调节杀虫活性或除草剂抗性。
定义
为了清楚地理解本发明，给出如下定义：
“合成”的意思是不在自然界发生。为了本发明的目的，合成序列不意在包含通过自然发生突变而生成或通过化学或生物机制如位点定向诱变诱导的突变而来的序列。在一些实施方案中，合成核苷酸序列是或是指在它整个或绝大部分编码区域被化学地合成。化学合成核苷酸序列的方法在本领域中已知(参见，例如Ausubel等，编著。分子生物中的现代协议(2000)第8.2B章节，卷1，John Wiley & Sons，纽约；Xiong等(2004)氨基酸研究，32：e98；Ovchinnikov等(1984)基因31：65-78；Khudyakov等(1993)氨基酸研究，21：2747-2754)。
合成序列包括核苷酸序列，其在至少大约1％，至少大约5％，至少大约10％，至少大约15％，至少大约20％，至少大约25％，至少大约30％，至少大约35％，至少大约40％，至少大约45％，至少大约50％，至少大约55％，至少大约60％，至少大约65％，至少大约70％，至少大约75％，至少大约80％，至少大约85％，至少大约90％，至少大约95％，或至少大约100％的相对于亲本序列的核苷酸位置与天然发生的亲本序列不相同。要认识到核苷酸序列可以在序列一定区域内被优化，其序列剩余部分相对于亲本序列保持不变。为了本发明的目的，术语“合成的核苷酸序列”以及“优化的核苷酸序列”可互换使用。
“N长度区域”，或“NLR”表示对应于感兴趣的核苷酸序列的一个区域的长度为N的连续核苷酸序列。例如，一个NLR可以是从大约1到大约100的核苷酸长度，或者是从大约2到大约50，或从大约3到大约40，或从大约4到大约30，或从大约5到大约20，或从大约6到大约15，或者大约10的核苷酸长度。在一些实施方案中，NLR在长度上大于或小于3个核苷酸。
“N长度序列”或者“NLS”表示任何N长度的连续核苷酸序列。对于任何给定的优化运行，每一NLS的长度等于每一NLR的长度。如图1所示。在此例中，感兴趣的核苷酸序列被12个核苷酸代表，并且每一NLR长度为5个核苷酸。因此，每一NLR的每一NLS也是5个核苷酸长度。
可以理解这里描述的方法能够被用于从单个感兴趣的核苷酸序列生成单个优化的序列，以及从单个感兴趣的核苷酸序列生成多个不同的优化序列。产生多个不同被优化的序列时，在每一个优化运行中一个或多个优化参数被改变以使不同被优化的序列从运行中产生。一个这样可被改变的参数就是NLS和NLR中“N”所代表的值。
这里揭示的方法的步骤在随后的模块中进行阐述。
模块A，开发目标数据库
本发明的方法需要一个核苷酸序列目标数据库。“目标数据库”可为一个或多个核苷酸序列的任何数据库，例如
模块B，组织作为N长度寡聚物序列集的数据库
在本发明的此方面，以NLS统计表(或者“NLS Stats Table”)的形式从目标数据库中组织数据。通过设置“N”长以及确定数据库中代表每一可能N长度片段的频率生成NLS统计表。N的值可基于目标数据库的容量(即所有在该数据库中的序列)任意选择。通常地，长些的NLR序列比短些的NLR序列捕获更多的信息，但NLS统计表条目数目被序列长度控制，并且过长的表会减缓算法执行以及降低统计精确度。一个空NLS统计表通过首先列出每一个n长度的可能序列而生成。例如，对于n＝5，NLS统计表会有1024个条目(AAAAA，AAAAC，AAAAG...TTTTT(分别地，SEQ ID NO：3-6)。
NLS统计表可通过计算数据库中所代表的每一NLS计数次数而被编译，例如通过使用“滑动窗口”算法扫描数据库中每一个序列。备选地，NLS统计表可通过使用任何其他统计学上合理策略被编译，例如从数据库中随机抽样短序列。滑动窗口算法在本领域中是已知的。在一个实施方案中，算法通过一次滑动一个或多个核苷酸而在目标数据库中沿着每一序列移动以编译NLSs列表。例如，在一个假定目标数据库(包括由AGTGCAAGTACGTAA(SEQ ID NO：7)所代表的核苷酸序列，其中N被设为5)中，第一个NLS是AGTGC，第二个NLS是GTGCA，第三个NLS是TGCAA，等等。在目标数据库中的每一个序列被编译为NLSs集。滑动窗口算法计算来自空NLS统计表的每一NLS在数据库中代表的次数。例如，算法扫描所有序列并计算NLS“AAAAA”，NLS“AAAAC”，NLS“AAAAG”出现在数据库中的次数等等。此原始计数被在数据库中观测的NLSs总数相除以得到一个观测频率值。
对于每一NLS，计算概率得分，其代表每一NLS相对于在目标数据库中期望发生频率的观测频率。在一个例子中，将概率得分转变为对数概率得分并且等于log10[数据库中NLS观测频率/数据库中NLS期望频率]。
期望频率的计算方法可不同。在一方面，每一核苷酸被认为同样可能。在这种情况下期望频率将为0.25N，其中N是上述NLR/NLS指定的长度。因此，对于在前提及的5-mer NLS(AGTGC)，其期望频率将为0.25N＝0.0098。
在另一实施方案中，基于目标数据库中每一核苷酸相对频率的一个频率被使用。每一核苷酸的相对频率被计算作为目标数据库(对于该核苷酸的“数据库频率”)中整个所有序列(全体地)中的核苷酸G，C，T和A的分数表示。在这种情况下，为每一N长度序列计算NLS的期望频率：通过(1)对于NLS每一位置，记录该位置(A，G，C，或T)上代表的核苷酸的数据库频率；以及然后(2)计算那些数据库频率乘积以为整个NLS生成期望频率。例如，如果整个数据库基本组成是A＝0.20，G＝0.30，T＝0.20，C＝0.30，NLS“AGTGC”的期望频率将为0.2×0.3×0.2×0.3×0.2＝0.00072。
在数据库中特定NLS观测频率大于被计算的期望频率的情况下，被观测/被期望的比率大于1并且对数概率得分是正数。在观测频率小于期望频率的情况下，该比值小于1并且对数概率得分是负数。因此，对于每一NLS，正的对数概率意味着NLS比统计学上期望的更频繁地被观测到，并且负的对数概率意味着NLS比统计学上期望的更加不经常地被观测到。
在给定NLS没有在数据库中被观测的情况下(即观测频率为0)，使用近似值。在一个例子中，观测频率设为[1/1+数据库中被观测的NLSs总数]。在另一个例子中，选择低于NLS统计表中最低观测频率的任意值。从而，未被观测的NLSs典型地相对于被观测的NLSs具有非常低的概率得分。
记分模块
在本发明的一方面，模块B被用于评估特定序列(或多个序列)与NLS统计表的适合度。例如，感兴趣的序列可被扫描以寻找低得分区域，或者计算整个序列的累积得分。此累积得分可被用于，例如比较编码相同氨基酸的两个不同核苷酸序列以确定哪一个序列更适于在目标生物体中表达。尽管不被任何特定的理论或机制所束缚，可提议具有低得分区域优势的序列(或具有更低累积得分序列)比具有更高得分区域优势的序列(或具有更高累积得分序列)在目标生物体中有更低水平的表达。一种评估序列与NLS统计表的适合度的方法包括：
a.提供一NLS统计表(如为目标生物体的NLS统计表，感兴趣的序列在其中被表达)；
b.识别感兴趣序列中的每一个NLR，例如使用如上所述的滑动窗口算法；
c.为每一NLR读出在该位置的NLS；
d.使用NLS统计表寻找在步骤b和c鉴定的每一NLS的对数概率得分。该NLS概率值被用作为在感兴趣序列中每一NLR位置的概率值。
e.对所有NLR位置的对数概率得分求和以为感兴趣的序列生成一个总得分。注意求和的对数得分与基础(非对数)概率值相乘是等同的。
f.该方法为整个序列提供一个累积得分。
另一种评估序列与NLS统计表的适合度的方法涉及在感兴趣的较大序列中寻找低得分片段。此低得分片段可代表转基因表达的重要障碍，或者足以破坏表达。该方法包括：
a.细分一感兴趣的序列为更小的片段。这些片段可重叠。例如，一个1000bp序列可被分为多个50bp片段；
b.使用与上述相似的方法对这样鉴定每一片段记分；
c.为每一片段记录分值；
d.对在该序列中等同于最低计值的片段的全序列赋予一个分值。
模块C.优化模块
当感兴趣的核苷酸序列是一感兴趣蛋白质的编码序列时，评估每一给定NLR的所有可能列表以及鉴定那些不破坏可读框和/或经编码的氨基酸序列(即关于蛋白质翻译是“沉默的”)的NLSs将是必要的。这里所涉及的这些NLSs集合称作沉默NLSs列表或“SNLS”。
在本发明的一方面，SNLS列表通过使用感兴趣的整个序列作为翻译和评估的基础来生成。该方法包括：
a.对于感兴趣序列中的每一NLR，在该位点上将每个可能的NLS取代初始的感兴趣的序列。例如，对于n＝5，存在1024个可能的序列(AAAAA，AAAAC，AAAAG...TTTTT)。
b.将整个感兴趣的初始序列以及新生成的取代序列翻译成氨基酸序列。
c.比较两个氨基酸序列。如果两个翻译是相同的，取代被认为是沉默的并且在这一轮用到的NLS被加到针对那个NLR位置的SNLS列表。
d.在评估每一可能NLS后，该位置的SNLSs列表被完成。
在本发明的另一个方面，SNLS列表通过执行仅仅有限的翻译和在被检查NLR的附近进行比较来被生成。该方法相对于上文所述的方法在计算上是优选的。该方法包括：
a.为感兴趣序列中的每一NLR，建立NLR周围的翻译框内窗口。这如下完成：通过在5′和/或3′方向扩展NLR，使得i)区域长度变为3倍(以适应遗传密码的三联体性质)，并且ii)扩展区域的开始位置与初始全长序列(即亲本序列)的翻译框架在框内。
b.使用对应于扩展区域的亲本序列作为基础序列，在对应于步骤a中起始NLR的位置上将每个可能的NLS取代该基础序列。
c.翻译初始基础序列以及新生成的取代序列至氨基酸序列。
e.比较两个氨基酸序列。如果两个翻译是相同的，该取代被认为是沉默的并且将在该轮中使用的NLS加到针对那个NLR位置的SNLS列表中。
f.在评估每一可能NLS后，该位置的SNLS的列表完成。
在本发明的另一个方面，SNLS列表通过首先为每一NLR创建翻译的肽，而后从所有可编码翻译的肽的简并核苷酸序列集合中选择SNLS成员而被生成。该方法包括：
a.为感兴趣序列中的每一NLR，在其周围建立一可翻译的框内窗口。这如下完成：在5′和/或3′方向扩展NLR，使得i)区域长度变为3倍(以适应遗传密码的三联体性质)，并且ii)扩展区域的开始位置与初始全长序列的翻译框架在框内。
b.使用对应于扩展区域的亲本序列作为基础序列，生成一目标氨基酸序列(即翻译该区域的初始核苷酸序列)。
c.生成编码目标氨基酸序列的所有核苷酸序列集合。由于遗传密码的冗余性，该序列集被认为是“简并的”。
d.从简并的序列集合，识别并记录在对应于步骤a中初始NLR的位置中的N-长度序列。
e.在步骤d中识别的所有NLSs列表，减去任何重复就是该位置的SNLS列表。
下一步，使用该NLS统计表对每个SNLS的得分赋予分值，并且对每个SNLS计算delta得分。“delta得分”或“△”代表感兴趣的核苷酸序列的NLR初始序列与每一对应SNLS之间概率得分的差异(△＝沉默-初始)。因此，正delta得分指示了SNLS相比初始序列更类似于目标数据库中的序列(具有更高概率得分)，并且delta得分的幅度对应于在目标数据库中观测的偏差度。然后，对于每一NLR，SNLSs列表按delta得分从最高到最低排序。为个别的NLR生成的SNLSs列表在这里被称作该特定NLR的“对应SNLS列表”。这样，每一NLR都有其自己对应的SNLS列表。
为了优化序列，通常的策略是用具有最大delta得分的SNLS代替每一NLR的初始NLS。这些取代的净效果是使得初始序列的总体组成更接近于目标数据库中的序列组成。与此同时，初始序列的低得分子片段被更高得分片段所代替，而保留整个序列的初始翻译。
一个执行该模块步骤的示例算法可包括如下步骤：
1)为操作序列，设置序列作为“输入序列”。
2)基于用于该NLS统计表的N-长度来开发在该输入序列中所有NLR位置的列表。典型地，在一个序列中存在着[L-N+1]个NLR位置，其中L是该初始序列的长度。
3)为每一NLR生成一个相应SNLSs列表。
4)通过检查每一对应SNLSs列表为整个序列选择最高得分SNLS(如有最高delta得分的SNLS)。在相同delta得分的情况下，最5’位置被首先使用。
5)为具有最高得分SNLS的NLR，将该NLR序列设定为对应于最高计分SNLS的序列。
6)暂时地“锁定”与刚刚改变的位置重叠的任何NLR，包括自身改变的NLR。要求这个步骤来防止“翻转”或其中一个单一的限定区域通过重叠取代被改变回去的其他循环过程。在该轮优化的剩余部分的过程中被锁定的NLR不被认为是NLS取代。然而，它们在随后的循环中被解锁以允许该序列的全部优化。
7)从剩余的解锁NLR的列表以及对应的SNLS列表中选择该整个序列的最高计分SNLS。
8)重复步骤5至7直到序列中的每一个NLR处于(1)被锁定，或(2)已经包含其位置最高得分SNLS。在此，优化的一个循环完成。
9)解锁整个序列。
10)使用上面描述的NLS统计表为整个序列生成得分。
11)从步骤1开始重复优化步骤，使用先前循环的序列作为输入序列。
12)继续重复步骤1至11(即执行顺序优化循环)直到两个连续的循环产生同样的得分序列。这表明无进一步优化可能。
13)从最后循环中输出序列作为“完全优化的序列”。
在本发明的另一方面中，直接从经翻译的亲本序列的氨基酸序列中进行初步的一轮优化。这种方法包括：
a.将该整个亲本序列翻译成一个氨基酸序列。
b.将该整个经翻译的基因分成多个邻接的肽段。每个肽段的长度可以在从1个氨基酸至经翻译的基因的整个长度之间(其中每一段是相同长度的)。用现有计算机系统优选大约3至大约10个氨基酸的长度。
c.对于每个肽段，产生对该片段进行编码的所有核苷酸序列的一个集合(一个简并序列的集合)。
d.使用该目标数据库生成的NLS统计表来对因此生成的每个简并核苷酸序列进行计分(参见模块B)。使用在以上说明的“计分模块”中披露的方法来计算该得分用于序列的子段计分。
e.对每个肽片段选出最大计分的核苷酸序列并且按顺序装配这些序列。
f.通过以上说明的额外的优化作用来通过该初步装配的序列。
在随后的任选的过程中(模块D和E)，进一步分析并调节从模块C得到的优化序列以去除任何无意的可读框或不令人希望的短DNA序列。
模块D.去除不令人希望的短DNA序列
在本发明的一个方面中，从该优选的序列中去除代表或据信能够代表不理想特征的某些短DNA序列。此类短DNA序列可以包括某些限制性酶识别序列、多腺苷酸化序列、5’和/或3’剪接识别位点、等等。这些元件可以由特定的使用者进行定义。
在本发明的一方面中，通过扫描不令人希望的元件的序列并且用不同的NLS从与这些短序列重叠的NLR替换NLS、从而破坏该短核苷酸序列，从该核苷酸序列中去除此类短DNA序列。优选地，用对总得分具有最低影响的NLS取代与该不令人希望的元件相重叠的NLS。在本文其他地方讨论了计算总分的方法。在编码DNA序列的优化作用的情况下，只允许SNLS取代，并且不允许引入假(即，无意的)ORF的取代。典型地重复这个循环，直至没有不令人希望的位点留下，尽管可能没有必要去除每个不令人希望的序列。短DNA序列的去除典型地是在根据本文中模块A、B和C的优化过程中或之后进行的，或可以在这些模块中任一者的缺失下进行。
在本发明的一个方面中，可以将特定的不令人希望的序列(如多腺苷酸化位点)从一个优化序列中去除。按照这种方式，在这种知识是可获得的情况下，该方法可以实现大体上的优化以及特异性位点校正。多腺苷酸化位点的实例包括但不限于：AATAAA、AATATT、AACCAA、ATACTA、AATGAA、GATAAA、ATATAA、ATAAAA、ATTAAT、AATAAT、AATAAG、AATCAA、ATGAAA、AAGCAT、ATACAT、AAAATA、ATTAAA、AATTAA、AATACA、以及CATAAA(分别是SEQ ID NO：8至11、1、以及12至26)(参见，例如，Zhao et al(1999)Microbiol.MoI.Biol.Rev.63：405-445)。＜0}植物特异性多腺苷酸化位点说明于Joshi(1987)Nucleic Acids Res.15：9627-9640和Rothnie(1996)Plant MoI.Biol.32：43-61中。原核多腺苷酸化位点讨论于Sarkar(1997)Annu.Rev.Biochem.66：173-197中。聚合酶终止信号包括但不限于(CAN)7-9AGTNNAA(参见，例如Vankan and Filipowicz(1988)EMBO J.7：791-799)。共有的剪接位点包括但不限于：5’-AAG：GTAAGT以及3’-TTTT(Pu)TTT(Pu)T(Pu)T(Pu)T(Pu)TGCAG：C(参见，例如Brown et al.(1986)EMBO J.5：2749-2758；Hanley and Schuler(1988)Nucleic AcidsRes.16：7159-7176)。剪接位点最恒定的残基是5′-GT和3′-AG。
这个优化的核苷酸序列也可以通过用NLS进行取代来进行进一步修饰，这些NLS具有生成稳定的RNA二级结构的更低概率。此类二级结构包括但不限于发夹环(转折结构)。能够形成发夹环的序列包括但不限于CUUCGG(SEQ ID NO：27)和UCUUCGG(SEQ ID NO：28)(参见，例如Tuerk et al.(1988)Proc.Natl.Acad.Sci.U.S.A.85：1364-1368)。
此外，该优化序列可以通过消除不需要的短核苷酸共有序列(如限制性核酸内切酶的识别位点、多腺苷酸化序列、5’和3’剪接识别序列等)的发生进行进一步优化。
模块E.去除额外的ORF
在本发明的另一方面中，从该优化序列中去除不编码感兴趣的蛋白质的可读框(ORF)。这种不令人希望的或“假的”ORF是通过用破坏该假ORF的NLS替换在假ORF内部的NLR位置上的NLS而实现的。“内部NLR”是落在该假ORF的边界内的NLR，如该感兴趣的序列的全框翻译所鉴定。在这个实施方案中，针对假ORF的存在对该序列进行扫描。下一步，鉴定在假ORF内部的NLR位置。对在这些NLR位置上的SNLS取代进行评估，并且基于如以上说明的δ得分选出破坏该假ORF的那些SNLS取代。典型地，选择了对总得分具有最低影响的SNLS。因为只考虑了SNLS，选择在不中断该初始ORF的同时破坏任何假ORF的取代。可以将这个循环重复以生成越来越完美的优化序列，或直至去除具有长度大于约1000、约900、约800、约700、约600、约500、约400、约300、约200、约100、或大于约75个核苷酸的假ORF。
模块F.GC含量的优化
在本发明的又一个方面中，可以进一步改变该优化的核苷酸序列以调节该优化序列的GC含量。通过用具有不同GC含量的NLS取代在NLR上的NLS可以实现该改变。不应当允许引入假ORF或不令人希望的短DNA序列的取代。在一个实例中，检查了所有NLR上的所有可能的SNLS，并且鉴定出当改变净GC含量时对总得分具有最小影响的那些SNLS。用如以上说明的锁定进行反复取代，直至该基因的总GC含量达到一个目标阈值，例如GC含量为大约40至大约60％，例如大约60％、大约59％、大约58％、大约57％、大约56％、大约55％、大约54％、大约53％、大约52％、大约51％、大约50％、大约49％、大约48％、大约47％、大约46％、大约45％、大约44％、大约43％、大约42％、大约41％、大约40％、大约39％、或大约38％。
在一个实施方案中，该优化核苷酸序列的GC含量是均匀遍及该整个核苷酸序列的。通过“均匀遍及”一词，该核苷酸序列是要指该全长优化序列的任何定义的子段的GC含量具有一个GC含量，该GC含量类似于该全长优化序列的任何其他定义子段的GC含量。通过“类似于”该GC含量，它是要指参比子段的GC含量是在大约20％内、大约19％内、大约15％内、大约10％内、大约9％内、大约8％内、大约7％内、大约6％内、大约5％内、大约4％内、大约3％内、大约2％内、大约1％内，或小于相比较的参比部分的亚部分的GC含量。
计算机实现的方法
以上说明的用于生成合成的核苷酸序列的方法可以通过使用计算机程序或计算机实现的方法来全部或部分地进行。
本发明的计算机程序和计算机程序产品包括计算机可用的介质，其在其中存储控制逻辑，用于使计算机生成对感兴趣的多肽进行编码的合成的核苷酸序列。在一个实施方案中，该计算机程序包括计算机可用的介质，在其中存储有控制逻辑，用于使计算机生成NLS统计表，该控制逻辑包含用于使该计算机接受通过输入装置输入的外部信息的第一代码，其中该外部信息包括DNA序列的数据库以及n长度的指定值。控制逻辑也被称作计算机可读的和/或计算机可执行的代码。
在另一个实施方案中，该计算机程序包括计算机可用的介质，在其中存储控制逻辑，用于使计算机生成对感兴趣的多肽进行编码的优化的核苷酸序列，该控制逻辑包括用于使该计算机接受通过输入装置输入的外部信息的第一代码，其中该外部信息包括NLS统计表、以及有待优化的核苷酸序列。控制逻辑也被称作计算机可读和/或计算机可执行的代码。
在另一个实施方案中，该计算机程序包括计算机可用的介质，在其中存储有控制逻辑，用于使计算机生成对感兴趣的多肽进行编码的优化的核苷酸序列，该控制逻辑包括用于使该计算机接受通过输入装置输入的外部信息的第一代码，其中该外部信息包括优化的核苷酸序列的DNA序列、以及一个较不希望的DNA和蛋白序列的集合(例如，在本文的其他地方披露的短的不令人希望的DNA序列)。控制逻辑也被称作计算机可读取和/或计算机可执行的代码。
在另一个实施方案中，该计算机程序包括计算机可用的介质，在其中存储控制逻辑，用于使计算机生成对感兴趣的多肽进行编码的合成(“优化”)的核苷酸序列，该控制逻辑包括使该计算机接受通过输入装置输入的外部信息的第一代码，其中该外部信息包括DNA序列的数据库、n-长度的一个指定值、以及针对其开发一个或多个优化基因的一个氨基酸序列；用于使该计算机从输入中生成NLS统计表的第二代码；用于开发NLR集合的第三代码、用于确定不破坏该可读框(“沉默NLSs”或“SNLS”)的这个NLS集合的第四代码、以及用于优化SNLS装配中的选择以得到优化的基因序列的第五代码。
用于生成对感兴趣的多肽进行编码的合成的核苷酸序列的本发明的计算机系统包括处理器(进行运算以确定、接受，检查、并显示数据)、与所述处理器相连接用于存储数据的存储器、与所述处理器相连接用于显示数据的显示装置、与所述处理器相连接用于输入外部数据的输入装置；以及一个具有至少两种所述处理器可执行的操作模式的计算机可读的脚本。计算机可读取脚本可以是一个计算机程序或本发明的一个实施方案的计算机程序产品的控制逻辑。
对于本发明而言以任何具体的计算机语言来写这个计算机程序或在任何特定类型的计算机系统或操作系统上操作不是关键性的。例如，可以用C++、Java、Perl、Python、Ruby、Pascal、或Basic编程语言来编写这个计算机程序。应当理解，可以用多种不同的编程语言之一来产生这个程序。在本发明的一个方面中，写出该程序以便在使用Linux操作系统的计算机上运行。在本发明的另一方面中，写出该程序以便在使用MSWindows或MacOS操作系统的计算机上运行。
本领域的技术人员应当理解根据本发明可以按任何顺序或同时执行代码，只要该顺序符合逻辑流。
在一个实施方案中，该计算程序具有对于使用者插入所希望的氨基酸序列的一个输入空间、以及显示生成的核苷酸序列的一个输出空间。在一个实施方案中，该计算机程序具有一种编辑模式，其中可以如使用者所希望修改对于每个NLR选择每个NLS的概率。
用于优化的核苷酸序列
对于感兴趣的多肽进行编码的任何核苷酸序列可以生成合成(或“优化的”)的核苷酸序列，包括但不限于：对杀虫蛋白、除草剂耐受性蛋白、真菌耐受性蛋白、水解酶类(包括改变植物谷物中糖类、蛋白质、或脂类/油的量和/或性质的酶类)、品质性状、或任何其他感兴趣的蛋白质进行编码的序列。杀虫蛋白包括δ-内毒素蛋白，如来自苏云金芽孢杆菌中的那些蛋白。
通过“杀虫”一词是要指带来至少一种害虫死亡或明显地减少害虫生长、摄食、或正常生理发育的能力。“杀虫”化合物是一种具有抗昆虫种类中的害虫的活性的化合物。“除草剂耐受性蛋白”或从“编码除草剂耐受的核酸分子”的表达中得到的蛋白包括多种蛋白质，它们与不表达该蛋白的细胞相比赋予细胞耐受更高浓度的除草剂的能力、或与不表达该蛋白的细胞相比耐受一定浓度的除草剂更长时间的能力。
以下实施例是通过阐明方式但不作为限制来提供的。
实验
实施例1.使用一个5级统计模型优化在玉蜀黍中表达的细菌δ内毒素基因
步骤1：识别并且收集玉蜀黍cDNA序列(模块A)。从公共资源(例如)中收集有待在玉蜀黍中表达的本领域内已知的编码区域的序列。这些序列由mRNA、cDNA、或代表这些编码序列的基因组片段组成。按照需要，对这些序列进行编辑以去除非编码区(优选地通过在该序列群体中识别可读框(ORF)区域)。
步骤2：用N＝5生成针对玉蜀黍cDNA序列的NLS统计表。使用如在模块B中所说明的一个5碱基滑动序列窗对来自玉蜀黍的序列进行分析。生成了由所有可能的5碱基序列组成的一个表，并且记录了来自步骤1的在玉蜀黍序列集合中观察到的每个5碱基序列的计数。将观察到的计数除以观察到的5-碱基序列的总数生成原始频率值。将观察到的原始频率值除以预期的频率值以生成在玉蜀黍序列集合中所有5碱基序列(NLS)的观察：预期的比率。使用水平分布模型来定义该实例中的预期频率(即，每个NLS(5碱基序列)在1,024个可能的NLS(5碱基DNA序列)中被认为相同的可能性)。得到的表被称为NLS统计表。观察：预期的比率被认为是近似于观察到的5碱基序列中每一个的发生概率。
步骤3.用高概率序列替换在细菌δ内毒素基因中的低概率5碱基序列(NLS)。通过滑动窗分析来确定候选的δ内毒素基因(Axmi004；披露于在2003年3月18日提交的美国专利申请10/739,610中)以确定在该基因中每个5碱基序列(NLS其中N＝5)的相对相似性。所有的基因序列核苷酸位置是根据它们在玉蜀黍中发生的概率升序排序的，在这种情况下使用来自步骤2的NLS统计表进行近似。从最低概率序列位置开始，通过在不破坏该基因阅读框或向该基因氨基酸序列(SNLS)中引入突变的位置上识别所有可能的NLS(5碱基取代)来生成一个沉默取代的集合。在每个位置上，用具有最高玉蜀黍观察：预期比率(在NLS统计表中最高位次)的5碱基沉默取代(SNLS)取代现有的5碱基序列。如在模块C中(以上)所说明的重复该循环并且重复几轮，直至增加该基因序列的净可能性的额外的沉默变化是不可能的。得到的序列被认为是初步优化的基因。
步骤4.从该初步优化的基因中去除假ORF。通过用如以上在模块D中所说明的SNLS(5-碱基序列)替换在该初步优化基因(5碱基序列)中的NLS，从该初步优化基因中去除不编码该感兴趣基因的ORF。选出破坏任何识别的假可读框而不中断该初始可读框的取代(在这种情况下，Axmi004蛋白)。重复该循环直至在产生一个“剔除ORF的优化基因”的优化的基因中没有大于75个氨基酸的假可读框被保留。
步骤5.从该剔除ORF的初步优化基因中去除不令人希望的短DNA序列。通过用如以上在模块E中所说明的SNLS(5碱基序列)替换在该初步优化基因中的NLS，从该初步优化的基因中去除对不令人希望的特征(包括限制性酶识别序列)进行编码的短DNA序列。不允许引入假的ORF的取代。重复该循环直至没有留下不令人希望的位点，得到一个完全优化的基因。
步骤6.生成具有降低的GC含量的变体全优化基因。通过用如以上在模块F中所说明的SNL(5碱基序列)取代在该全优化基因中的NLSs来生成全优化基因的变体。不允许引入假可读框或不令人希望的短DNA序列的取代。评价所有可能的沉默取代，并且鉴定对观察：预期的比率具有最小影响同时仍降低净GC含量的那些沉默取代。以这种方式反复进行取代直至使该基因的总GC含量低于50.0％的目标阈值。该序列被认为是低于50％GC的优化基因。
实施例2
以下算法提供了用于实施本发明的方法的算法的函数集合的一个实例。
# Synthetic gene creation and optimization classes
#
# ########################################
# This program is the property of Athenix Corp.
# All rights reserved
# Daniel J.Tomso，programmer
# Created:07-Mar-06
# ########################################
#
# Modified:07-Mar-06，DJT
# Modified:08-Mar-06，DJT
# Modified:09-Mar-06，DJT
# Modified:10-Apr-06，DJT
# Modified:11-Apr-06，DJT
# Modified:12-Apr-06，DJT
# Modified:26-Apr-06，DJT
# Modified:27-Apr-06，DJT
# Modified:28-Apr-06，DJT
# Modified:01-May-06，DJT
# Modified:17-May-06，DJT
# Modified:01-Jun-06，DJT
# Modified:18-Sep-07，DJT(Beginning of experimental re-write for
protein-directed opt)
# Modified:23-Jan-08，DJT(tweaks for new orf handling requirements)
# Modified:16-Apr-08，DJT(clean out non-CATG seqs in keys)
# Modified:12-Aug-08，DJT(begin major upgrade)
import re
import sys
import pickle
from math import log
from seq_handler import SeqHandler
from orf_classes import OrfFinder
class SeqStats:
″″″Base n-order sequence statistics class.″″″
def_init_(self，order＝5):
″″″Initialize by passing in an order(oligo length)value.″″″
self.order＝order
self.oligo_count＝0
self.oligos＝self.build_oligos()
self.oligo_stats＝{}
def build_oligos(self):
″″″Builds an empty dictionary of all n-order oligos.″″″
oligo_keys＝[″]
for i in range(0，self.order):
new_oligos＝[]
for oligo in oligo_keys:
for base in[′A′，′C′，′G′，′T′]:
noligo＝oligo+base
new_oligos.append(noligo)
oligo_keys＝new_oligos
oligos＝{}
for oligo in oligo_keys:
oligos[oligo]＝0
return oligos
def add(self，oligo):
″″″Adds an oligo stats matrix.″″″
if re.search(′[^ACGT]′，oligo):
return
self.oligos[oligo]+＝1
self.oligo_count+＝1
def add_seq(self，sequence):
″″″Adds all oligos from a sequence to the stats matrix.″″″
sequence＝sequence.upper()
for i in range(0，len(sequence)-self.order+1):
oligo＝sequence[i:i+self.order]
self.add(oligo)
def update(self):
″″″Calculates the statistics matrix from the current raw count
values.″″″
notseen＝log(1/float(self.oligo_count+1))
stats＝{}
expected＝0.25＊＊self.order
for oligo in self.oligos:
if self.oligos[oligo]＝＝0:
stats[oligo]＝notseen
else:
observed＝self.oligos[oligo]/float(self.oligo_count)
stats[oligo]＝log(observed/expected，10)
self.oligo_stats＝stats
def sscore(self，sequence):
″″″Returns a log probability score for a given sequence.″″″
sequence＝sequence.upper()
score＝0
for i in range(0，len(sequence)-self.order+1):
oligo＝sequence[i:i+self.order]
score+＝self.oligo_stats[oligo]
return score
def save(self，filename):
″″″Simple pickle routine to save N-order stat data to file.″″″
dataset＝[self.order，self.oligo_count，self.oligos，
self.oligo_stats]
savefile＝open(filename，′w′)
pickle.dump(dataset，savefile)
savefile.close()
print″Data saved to％s″％(filename)
def load(self，filename):
″″″Simple pickle routine to load N-order stat data from file.
″″″
loadfile＝open(filename，′r′)
(self.order，self.oligo_count，self.oligos，self.oligo_stats)＝
pickle.load(loadfile)
loadfile.close()
class SiteManager():
″″″Class to manage site detection and preservation operations in
DNA.″″″
def_init_(self，tablefile):
self.siteset＝self.load(tablefile)
def load(self，filename):
″″″Loads a table of sites into grouped sets.″″″
siteset＝{}
loadfile＝open(filename，′rU′)
for line in loadfile:
line＝line.rstrip()
if re.match(′#′，line):#comment line
continue
group，sequence＝line.split(′ ′)
if siteset.has_key(group):
siteset[group].append(sequence)
else:
siteset[group]＝[sequence]
return siteset
def findsites(self，sequence):
″″″Finds all instances of the siteset in a sequence，returns a
dictionary with paired sites and locations.″″″
sitetable＝{}
for group in self.siteset.keys():
for siteseq in self.siteset[group]:
siteiter＝re.finditer(siteseq，sequence)
for sitematch in siteiter:
if sitetable.has_key(group):
sitetable[group].append([siteseq，
sitematch.start()])
else:
sitetable[group]＝[[siteseq，
sitematch.start()]]
return sitetable
class SeqOptimizer(SeqStats):
″″″Derived class for sequence optimization using n-order sequence
statistics.″″″
def_init_(self，sequence，statfile，order＝5):
SeqStats._init_(self，order)
self.load(statfile)
self.seq＝sequence
self.length＝len(sequence)
self.sh＝SeqHandler()
self.opt_table＝{}
self.changedsites＝[]#list of sites changed during
optimization rounds
def sequence(self，sequence＝None):
″″″Returns the current sequence，or updates the sequence.″″″
if sequence is None:
return self.seq
else:
self.seq＝sequence
def score(self，sequence＝None):
″″″Overrides basic score--returns current sequence score if no
parameter specified，otherwise scores passed sequence.″″″
if sequence:
score＝self.sscore(sequence)
else:
score＝self.sscore(self.seq)
return score
def segments(self，oligo，position):
″″″Returns segments for substitution method.″″″
offset＝self.order-1
begin＝position-offset
begin＝begin-(begin％3)
end＝position+self.order+offset
end＝end+(3-end％3)
if begin＜0:
begin＝0
if end＞self.length:
end＝self.length
org_dna＝self.seq[begin:end]
prefix＝self.seq[begin:position]
suffix＝self.seq[position+self.order:end]
new_dna＝prefix+oligo+suffix
return org_dna，new_dna
def segment(self，position):
″″″Returns cleanly-translatable sequence segment and offset
correction for degeneration method.″″″
offset＝self.order-1
begin＝position-offset
begin＝begin-(begin％3)
end＝position+self.order+offset
end＝end+(3-end％3)
if begin＜0:
begin＝0
if end＞self.length:
end＝self.length
org_dna＝self.seq[begin:end]
correction＝position-begin
return org_dna，correction
def silent(self，org_dna，new_dna):# use with substitution method
″″″Returns 1 if a silent mutation，0 if an aa change is
introduced.″″″
org_aa＝self.sh.translate(org_dna)
new_aa＝self.sh.translate(new_dna)
if org_aa＝＝new_aa:
return 1
else:
return 0
def delta(self，org_dna，new_dna):
″″″Returns the delta score for two DNA segments.″″″
org_score＝self.score(org_dna)
new_score＝self.score(new_dna)
return new_score-org_score
def subs(self，position，threshold＝-100000.0):
″″″Degeneration-based silent substitution routine.″″″
org_dna，correction＝self.segment(position)
org_aa＝self.sh.translate(org_dna)
org_oligo＝self.seq[position:position+self.order]
degenerates＝self.sh.degenerate(org_aa)
nsubs＝{}
for degenerate in degenerates:
oligo＝degenerate[correction:correction+self.order]
if self.score(oligo)＜threshold:
continue
if nsubs.has_key(oligo):
continue
else:
prefix＝org_dna[:correction]
suffix＝org_dna[correction+self.order:]
new_dna＝prefix+oligo+suffix
new_aa＝self.sh.translate(new_dna)
if new_aa<>org_aa:
continue # some non-silent possibilities depending
on position and frame
delta＝self.delta(org_dna，new_dna)
nsubs[oligo]＝delta
subs＝[]
for oligo in nsubs.keys():
delta＝nsubs[oligo]
subs.append([delta，oligo])
subs.sort(cmp＝lambda x，y:cmp(x[0]，y[0]))
return subs
def old_subs(self，position，threshold＝-100000.0):
″″″Returns a scored list of silent substitutions for the given
position and sequence.″″″
subs＝[]
for oligo in self.oligos:
org_dna，new_dna＝self.segments(oligo，position)
if self.silent(org_dna，new_dna):
delta＝self.delta(org_dna，new_dna)
if self.score(oligo)＜threshold:
continue
subs.append([delta，oligo])
if len(subs)＝＝0:
subs.append([0.0，self.seq[position:position+self.order]])
subs.sort(cmp＝lambda x，y:cmp(x [0]，y[0]))
return subs
.def update_opt_table(self):
″″″Updates the optimization table for every site in the changed
site list.″″″
for i in self.changedsites:
oligo＝self.seq[i:i+self.order]
best_delta，best_oligo＝self.subs(i)[-1] # default
threshold，accepts all subs
self.opt_table[i]＝([best_delta，best_oligo])
def site_collision(self，position):
″″″Tests for overlap between the region surrounding position
and the site table.″″″
offset＝self.order-1
for i in range(position-offset，position+self.order+
offset):
if i in self.changedsites:
return True
return False
def update_site_table(self，position):
″″″Updates the changed site table for all site overlapping the
current position.″″″
offset＝self.order-1
begin＝position-offset
end＝position+self.order+offset
if begin＜0:
begin＝0
if end＞(self.length-self.order+1):
end＝(self.length-self.order+1)
for i in range(begin，end):
self.changedsites.append(i)
def opt_round(self):
″″″Performs a single round of non-overlapping low-position
optimization.″″″
self.update_opt_table()
self.changedsites＝[]
skeys＝self.opt_table.keys()
skeys.sort(cmp＝lambda x，y:cmp(self.opt_table[y][0]，
self.opt_table[x][0]))
maxdelta＝self.opt_table[skeys[0]][0] # largest observed delta
in the opt table
if maxdelta＜＝0.0:
return False # Not changed，converged
for position in skeys:
delta，oligo＝self.opt_table[position]
if delta＞0.0:
if self.site_collision(position):
continue
print″ Updating at position ％s，oligo is ％s，raw
score is ％2.3f，delta score is ％2.3f.″％
(position，oligo，self.score(oligo)，delta)
or_gaa＝self.sh.translate(self.seq)
prefix＝self.seq[0:position]
suffix＝self.seq[position+self.order:]
var_seq＝prefix+oligo+suffix
self.seq＝var_seq
self.update_site_table(position)
return True # Changed
def optimize(self，maxtries＝2000):
″″″Low-position-first optimization routine.″″″
self.changedsites＝range(0，self.length-self.order+1)
round＝1
while round＜＝maxtries:
print″ Beginning round ％s of optimization.″％(round)
changed＝self.opt_round()
print″ Round ％s completed.Sequence score is ％4.3f″％
(round，self.score())
if not changed:
print″ Optimization complete.″
return True
round+＝1
self.changedsites＝range(0，self.length-self.order+1)#
force rescan now that we have a faster algorithm
print″ Optimization incomplete after ％s rounds.″％(maxtries)
return False
def trace(self，sequence＝None):
″″″Generates a sliding-window traces of the sequence and
returns n-order stat scores for every position.″″″
if sequence is None:
sequence＝self.seq
trace＝[]
for i in range(0，len(sequence)-self.order+1):
oligo＝sequence[i:i+self.order]
trace.append([i，oligo，self.score(oligo)])
return trace
def lowscores(self，number＝10):
″″″Returns the lowest-scoring positions in the sequence.″″″
trace＝self.trace(sequence)
trace.sort(cmp＝lambda x，y:cmp(x[2]，y[2]))
lows＝[]
for i in range(0，number):
lows.append(trace[i][2])
return lows
class PSeqGenerator(SeqStats):
″″″Derived class for sequence optimization using n-order sequence
statistics and protein-based operations.″″″
def_init_(self，sequence，statfile，order＝5，segmentsize＝5，
stepsize＝3):
SeqStats._init_(self，order)
self.load(statfile)
self.aseq＝sequence # this is now an amino acid sequence
self.length＝len(sequence) # amino acid length
self.sh＝SeqHandler()
self.seq＝self.generate(segmentsize) # generates starting
optimal nucleotide sequence from protein sequence
def sequence(self，sequence＝None):
″″″Returns the current sequence，or updates the sequence.″″″
if sequence is None:
return self.seq
else:
self.seq＝sequence
def score(self，sequence＝None):
″″″Overrides basic score--returns current sequence score if no
parameter specified，otherwise scores passed sequence.″″″
if sequence:
score＝self.sscore(sequence)
else:
score＝self.sscore(self.seq)
return score
def candidate(self，position，segmentsize):
″″″New degeneration-based silent substitution routine，returns
candidate silent sequences of a given a.a.length.″″″
aa_segment＝self.aseq[position:position+segmentsize]
print″ Degenerating sequence ％s at position ％s″％(aa_segment，
position)
degenerates＝self.sh.degenerate(aa_segment)
high_degenerate＝″
high_score＝-10.0
for degenerate in degenerates:
if self.score(degenerate)＞high_score:
high_degenerate＝degenerate
high_score＝self.score(degenerate)
return high_degenerate，high_score
def generate(self，segmentsize):
DNA_seq＝″
for i in range(0，self.length，segmentsize):
best_DNA，best_score＝self.candidate(i，segmentsize)
DNA_seq＝DNA_seq+best_DNA
return DNA_seq
class SeqScrubber(SeqOptimizer):
″″″Derived class to handle scrubbing and GC drivedown operations on
optimized sequences.″″″
def_init_(self，sequence，statfile，order＝5，orfmax＝75，
threshold＝0.0，
sitetable ＝′/home/python/scrub_sites.table′，addtable
＝′/home/python/add_sites.table′):
SeqOptimizer._init_(self，sequence，statfile，order)
self.threshold＝threshold # minimum acceptable score for a
replacement oligo
self.orfmax＝orfmax # maximum acceptable length for a spurious
ORF
self.of＝OrfFinder(minlength＝self.orfmax)
self.stable＝self.load_scrubtable(sitetable)
self.scrublist＝[] # list of sites changed during scrubbing
operations
self.atable＝[]
self.deadorfs＝[]
self.origsites＝{}
def orfcount(self，sequence，verbose＝False):
″″″Counts the number of qualifying ORFs in a sequence.″″″
of_orfs＝self.of.get_orfs(sequence，require_atg＝False，
require_stop＝False)
orfs＝[]
if verbose:
for orf in of_orfs:
orfs.append([orf[′length′]，orf[′start′]])
if verbose:
return orfs
else:
return len(of_orfs)
def get_orf(self，psequence，start，end):
″″″Returns a cleanly-translatable ORF from the current
sequence.″″″
if start＜end:
subseq＝psequence[start:end]
else:
subseq＝psequence[end:start]
subseq＝self.sh.reverse_complement(subseq)
return subseq
def scrubintervals(self，lowpos，highpos):
″″″Generates discontinous intervals to attempt ORF scrubbing.
″″″
brange＝[]
fullorfnt＝self.orfmax＊3
maxorfnt＝int(fullorfnt＊0.8) # use 80％ of maximum for scrub
target
intsize＝(fullorfnt-maxorfnt)＊2 # pretty big，but we need
some targets
lowend＝lowpos+maxorfnt
highend＝highpos-maxorfnt
if lowend＞＝highend: # small orf，need slightly larger interval
center＝lowpos+(highpos-lowpos)/2
bmax＝center+intsize/2
bmin＝center-intsize/2
if bmax＜lowend:
bmax＝lowend
if bmin＞highend:
bmin＝highend
brange＝range(bmin，bmax)
else: # larger orf，these ranges will be too small if there is
only one interval！
multiple＝(highend-lowend)/maxorfnt+1 # how many
ranges we will be picking
fintsize＝intsize/multiple # pick the same number of
total sites
for i in range(lowend，highend):
if not(i-lowpos)％maxorfnt: # at a multiple of
maxorfnt
for j in range(i+intsize-fintsize，i+intsize):
brange.append(j)
return brange
def possibles(self，prange):
″″″Returns a list of possible silent substitutions in a range
of positions.″″″
possibles＝[]
for position in prange:
if position in self.scrublist:
continue # skip positions on the ′do not change′list
coligo＝self.seq[position:position+self.order]
psubs＝self.subs(position，threshold＝self.threshold)
for(pdelta，poligo)in psubs:
if poligo＝＝coligo:
continue # skip the existing oligo at this position
possibles.append([pdelta，poligo，position])
possibles.sort(reverse＝True)
return possibles
def variant(self，position，poligo):
″″″Returns the new variantsequence using poligo as a
substitute at the current position.″″″
prefix＝self.seq[0:position]
suffix＝self.seq[position+self.order:]
psequence＝prefix+poligo+suffix
return psequence
def scrub_orf(self，orf，force1＝False，force2＝False):
″″″Breaks up an ORF.Pass in an ORF instance.″″″
if orf[′end′]＞orf[′begin′]: # forward strand
scrubrange＝self.scrubintervals(orf[′begin′]，orf[′end′])
if force1:
scrubrange＝range(orf[′begin′]+30，orf[′end′]-30) #
maximum range
else: # reverse strand
scrubrange＝self.scrubintervals(orf[′end′]，orf[′begin′])
if force1:
scrubrange＝range(orf[′end′]+30，orf[′begin′]-30)
org_threshold＝self.threshold
if force2:
self.threshold-＝0.5
possibles＝self.possibles(scrubrange)
self.threshold＝org_threshold
for(pdelta，poligo，position)in possibles:
psequence＝self.variant(position，poligo)
porfseq＝self.get_orf(psequence，orf[′begin′]，orf[′end′])
ptrans＝self.sh.translate(porfseq)
if ′＊′in ptrans:
self.sequence(psequence) # update sequence to match the
variant
offset＝self.order-l
self.scrublist.append(position) # lock down the position
to avoid flipflops
print″ Solution found:％s at position ％s，delta is
％2.3f.″％(poligo，position，pdelta)
return True # successful scrub
return False # failed scrub
def orfcheck(self，variant):
″″″Compares ORF counts and positions in sequence and variant，
returns True if variant has the same ORFs as sequence.″″″
seq_orfs＝self.orfcount(self.seq)
var_orfs＝self.orfcount(variant)
if seq_orfs＝＝var_orfs:
return True
else:
return False
def sitecheck(self，variant):
″″″Compares scub site counts and positions for the primary
sequence and a variant，returns True if they match，False otherwise.″″″
seq_sites＝self.sitecount(self.seq)
var_sites＝self.sitecount(variant)
if seq_sites＝＝var_sites:
return True
else:
return False
def scrub_largest_orf(self):
″″″Attempts to re move the largest spurious ORF in the sequence.
″″″
orfs＝self.of.get._orfs(self.seq，require_atg＝False，
require_stop＝False)
orfs.sort(cmp＝lambda x，y:cmp(x[′length′]，y[′length′])，
reverse＝True) # sort ORFs by size
orfs_max＝len(orfs)-1
cur_orf＝1
while cur_orf＜＝orfs_max:
orf＝orfs[cur_orf] # next ORF to work on
print″ Largest spurious ORF is ％s amino acids，from
nucleotide ％s to ％s.″％(orf[′length′]，orf[′begin′]，orf[′end′])
orfkey＝str(orf[′begin′])+″_″+str(orf[′end′])
if orfkey in self.deadorfs:
print″ Skipping--unscrubbable ORF.″
cur_orf+＝1
continue
scrubbed＝self.scrub_orf(orf)
if scrubbed:
return True
else:
print″ Scrub failed--attempting again with force
level 1(expanded scrub range).″
scrubbed＝self.scrub_orf(orf，force1＝True)
if scrubbed:
return True
else:
″ Force failed--attempting again with force level
2(reduced substitution threshold).″
scrubbed＝self.scrub_orf(orf，force1＝True，force2
＝True)
if scrubbed:
return True
else:
print″ Force failed.ORF not scrubbed.″
self.deadorfs.append(orfkey)
return True # a change was made
return False # no changes made
def scrub_orfs(self):
self.deadorfs＝[]
scrubround＝0
orfcount＝self.orfcount(self.seq)
while orfcount＞1:
scrubround+＝1
print″ Round ％s，current ORF count is ％s″％(scrubround，
orfcount)
scrubbed＝self.scrub_largest_orf()
if not scrubbed:
return len(self.deadorfs)
orfcount＝self.orfcount(self.seq)
return 0 # orfcount is now 1，only primary ORF remains
def cleanup(self):
″″″Final post-scrubbing cleanup to check for optimizable sites.
″″″
prange＝range(0，self.length-self.order+1)
changed＝True
org_threshold＝self.threshold
self.threshold＝-10000.0 # allow all changes that produce a
positive delta
self.scrublist＝[]
while changed:
print″ Performing cleanup scan ...″
changed＝False
possibles＝self.possibles(prange)
for(pdelta，poligo，position)in possibles:
if pdelta＜＝0:
continue
seq_gc＝self.sh.gc(self.seq)
psequence＝self.variant(position，poligo)
var_gc＝self.sh.gc(psequence)
if var_gc＞seq_gc:
continue
if not self.orfcheck(psequence):
continue
if not self.sitecheck(psequence):
continue
self.sequence(psequence)
changed＝True
print″ Change made at position ％s，oligo is ％s，
delta is ％2.3f″％(position，poligo ，pdelta)
break
self.threshold＝org_threshold
def drivedown_gc(self，gc_target):
″″″Reduces GC content by making silent changes.″″″
prange＝range(0，self.length-self.order+1)
print″ Scanning sequence for possible changes...″
possibles＝self.possibles(prange)
saa＝self.sh.translate(self.sequence())
for(pdelta，poligo，position)in possibles:
seq_gc＝self.sh.gc(self.seq)
if seq_gc＜＝gc_target:
return True # threshold reached
psequence＝self.variant(position，poligo)
if self.sh.gc(psequence)＞＝self.sh.gc(self.seq):
continue # no GC decrease
if not self.orfcheck(psequence):
continue # change creates ORFs
if not self.sitecheck(psequence):
continue # change creates sites
paa＝self.sh.translate(psequence)
if paa<>saa: # a mutation，shouldn′t happen！
continue
self.sequence(psequence)
self.scrublist.append(position)
var_gc＝self.sh.gc(psequence)
gcdelta＝var_gc-seq_gc
print″ Updating at position ％s，oligo is ％s，delta is
％2.3f，new GC percentis ％3.2f.″％(position，poligo，pdelta，var_gc＊
100)
return False
def sitecount(self，sequence，verbose＝False):
″″″Counts the number of unscrubbed sites in the current
sequence.″″″
sitecount＝0
sitelist＝[]
for name in self.stable.keys():
site，comment＝self.stable[name]
for match in re.finditer(site，sequence):
sitelist.append([name，match.start()])
sitecount+＝1
if verbose:
return sitelist
else:
return sitecount
def load_scrubtable(self，tablefilename):
″″″Loads a table of sequences to scrub.″″″
stable＝{}
tfile ＝open(tablefilename，′r′)
for line intfile:
if re.match(r′ # ′，line):
continue
items＝re.split(r′s+′，line)
name，site＝items[0:2]
comments＝items[2:]
comment＝′′.join(comments)
stable[name]＝[site，comment]
return stable
def asegment(self，begin，end，sequence):
″″″Returns cleanly-translatable sequence segment.″″″
begin＝begin-(begin ％ 3)
end＝end+(3-end ％ 3)
if begin＜0:
begin＝0
if end＞len(sequence):
end＝len(sequence)
dna＝sequence[begin:end]
return dna
def scrub_site(self，site，position):
″″″Scubs a single site from a designated position in the
sequence.″″″
offset＝self.order-1
scrubstart＝position-offset
if scrubstart＜0:
scrubstart＝0
scrubend＝position+len(site)+offset
if scrubend＞self.length:
scrubend＝self.length
scrubrange＝range(scrubstart，scrubend)
possibles＝self.possibles(scrubranqe)
for(pdelta，poligo，position)in possibles:
psequence＝self.variant(position，poligo)
pregion＝psequence[scrubstart:scrubend]
if re.search(site，pregion):
continue # site is still present，skipthis solution
else:
if self.orfcheck(psequence):
self.sequence(psequence) # update sequence
self.scrublist.append(position) # lock down the
position to avoid flipflops
print″ Solution found:％s at position ％s，
delta is％2.3f″％(poligo，position，pdelta)
return True # change made
else:
print″ Rejected solution ％s at ％s for
extraneous ORF creation.″％(poligo，position)
continue
return False
def scrub_first_site(self，name):
″″″Attempts to scrub an instance of the named site from the
site table.″″″
(site，comment)＝self.stable[name]
print″ Attempting to scrub first incidence of site ％s，
sequence ％s.″％(name，site)
if not re.search(site，self.seq):
print″ No matches found for site ％s″％(site)
return ″nomatch″
for match in re.finditer(site，self.seq):
print″ Site found at positions ％s to ％s.″％
(match.start()，match.end())
scrubbed＝self.scrub_site(site，match.start())
if scrubbed:
return″scrubbed″
else:
print″ Unable to remove site，advancing to next
position.″
continue
print″ Matches not fixable with current parameters.″
return″failed″
def scrub_sites(self):
″″″Scrubs DNA sites out of an optimized sequence.″″″
targets＝self.sitecount(self.seq)
scrubround＝0
failures＝0
while(targets＞0 and failures＜10):
scrubround+＝1
print″ Round ％s，current site count is ％s.″％(scrubround，
targets)
for name in self.stable.keys():
scrubbed＝self.scrub_first_site(name)
if scrubbed is ″scrubbed″:
targets＝self.sitecount(self.seq)
break
elif scrubbed is ″nomatch″:
continue
else:
failures+＝1
continue
if(targets＝＝0 and failures＝＝0):
return True
else:
return False
# Driver for synthetic gene statistics creation
#
# ########################################
# This program is the property of Athenix Corp.
# All rights reserved
# Daniel J.Tomso，programmer
# Created:07-Mar-06
# ########################################
#
# Modified:07-Mar-06，DJT
# Modified:09-Mar-06，DJT
# Modified:12-Apr-06，DJT
# Modified:13-Aug-08，DJT(refined for new EST data，with complexity
filters)
import fasta_classes
import syngene_classes
import orf_classes
import sys
import re
def complexityscore(seq):
″″″Calculates a complexity score for an amino acid stretch，
typically an ORF.″″″
score＝0
for i in range(0，len(seq)-2):
if seq[i]＝＝seq[i+1]:
score-＝1
if seq[i-1:i]＝＝seq[i+1:i+2]:
score-＝1
adjscore＝score/float(len(seq))
return score，adjscore
def leastcomplexwindow(seq，windowsize＝20):
″″″Returns the lowestest score for n-length segments of the
sequence.″″″
leastscore＝0
for i in range(0，len(seq)-windowsize):
score，adjscore ＝complexityscore(seq[i:i+windowsize])
if score＜leastscore:
leastscore＝score
adjleastscore＝leastscore/float(windowsize)
return leastscore，adjleastscore
infile＝sys.argv[1] # Input in FASTA format
savefile＝sys.argv[2] # Filename to save stat data into
oorder＝int(sys.argv[3]) # Oligoorder--lengthof oligo to use in
analysis
orfminlength＝150
of＝orf_classes.OrfFinder(minlength＝orfminlength)
fp＝fasta_classes.FastaParser(infile)
ss＝syngene_classes.SeqStats(order＝oorder)
orfcount＝0
failed＝0
passed＝0
for seq in fp:
orfs＝of.get_orfs(seq.sequence，require_atg＝False，require_stop
＝False)
for orf in orfs:
if orf[′strand′]<>′forward′:
failed+＝1
continue
score，adjscore＝complexityscore(orf[′aa_seq′])
leastscore，adjleastscore＝
leastcomplexwindow(orf [′aa_seq′])
if adjleastscore＜-0.40 or adjscore＜-0.20:
failed+＝1
continue
passed+＝1
print″％s ％s ％3.3f ％s ％3.3f ％s ％s″％(orf[′length′]，
score，adjscore，leastscore，adjleastscore，passed，failed)
ss.add_seq(orf[′dna_seq′])
ss.update()
ss.save(savefile)
# Driver for synthetic gene optimization
#
# ########################################
# This program is the property of Athenix Corp.
# All rights reserved
# Daniel J.Tomso，programmer
# Created:07-Mar-06
# ########################################
#
# Modified:07-Mar-06，DJT
# Modified:08-Mar-06，DJT
# Modified:09-Mar-06，DJT
# Modified:13-Apr-06，DJT
# Modified:26-Apr-06，DJT
# Modified:27-Apr-06，DJT
# Modified:28-Apr-06，DJT
# Modified:17-May-06，DJT
import fasta_classes
import syngene_classes
import orf_classes
import sys
from seq_handler import SeqHandler
###### Globals ######
scrub_orf_size＝75 # maximum acceptable size for alternative ORFs in
sequence
gc_target＝0.50 # set to 1.00 for no drivedown
##### Reporting Routines #####
def show_sequence(opt_title，opt_seq，seqfile):
print″Optimized sequence:％s″％(opt_title)
print″Initial score:％4.2f Optimized score:％4.2f″％
(ss.score(org_seq)，ss.score(opt_seq))
print″Imitial GC percent:％3.2f Optimized GC percent:％3.2f″％
(ss.sh.gc(org_seq)＊100，ss.sh.gc(opt_seq)＊100)
fasta_classes.write(opt_title，opt_seq，seqfile)
def check_sequence(org_seq，opt_seq，sh):
org_aa＝sh.tramslate(org_seq)
opt_aa＝sh.translate(opt_seq)
if org_aa<>opt_aa:
print″Optimization error！Mutation introduced！″
sys.exit()
##### Main Program #####
infile＝sys.argv[1] # FASTA file of sequences to optimize
statfile＝sys.argv[2] # Pass in a stats file created by
syngene_builder.py
seqoutfile＝sys.argv[3] # Pass in a file name to write output sequences
to
seqfile＝open(seqoutfile，′a′)
sh＝SeqHandler()
fp＝fasta_classes.Fastaparser(infile)
for seq in fp:
org_seq＝seq.sequence.upper()
ss＝syngene_classes.SeqScrubber(org_seq，statfile，order＝5)
print″ Optimizing sequence％s...″％(seq.title)
ss.optimize()
check_sequence(org_seq，ss.sequence()，sh)
print″ Attempting to scrub spurious ORFs...″
unscrubbed＝ss.scrub_orfs()
if unscrubbed:
print″ Warning:％s unscrubbable ORF(s)remain.″％(unscrubbed)
check_sequence(org_seq，ss.sequence()，sh)
print″ Attempting to scrub disallowed sites...″
scrubbed＝ss.scrub_sites()
check_sequence(org_seq，ss.sequence()，sh)
print″ Final cleanup in progress...″
ss.cleanup()
check_sequence(org_seq，ss.sequence()，sh)
opt_seq＝ss.sequence()
opt_title＝seq.title+′_opt_full′
show_sequence(opt_title，opt_seq，seqfile)
print ″ Attempting GC drivedown to ％2.3f...″％(gc_target)
ss.drivedown_gc(gc_target)
check_sequence(org_seq，ss.sequence()，sh)
print″ Final cleanup in progress...″
ss.cleanup()
check_sequence(org_seq，ss.sequence()，sh)
opt_seq＝ss.sequence()
opt_title＝seq.title+′_opt_％s′％(gc_target)
show_sequence(opt_title，opt_seq，seqfile)
seqfile.close()
# Driver for synthetic gene optimization，v2(protein-based)
#
# ########################################
# This program is the property of Athenix Corp.
# All rights reserved
# Daniel J.Tomso，programmer
# Created:18-Sep-07，from syngene_optimize.py
# ########################################
#
# Modified:18-Sep-07，DJT
import fasta_classes
import syngene_classes
import sys
from seq_handler import SeqHandler
###### Globals ######
scrub_orf_size＝75 # maximum acceptable size for alternative ORFs in
sequence
gc_target＝0.50 # set to 1.00 for no drivedown
##### Reporting Routines #####
def show_sequence(opt_title，opt_seq，seqfile):
print ″Optimized sequence:％s″％(opt_title)
print ″Optimized score:％4.2f″％(ps.score(opt_seq))
print ″Optimized GC percent:％3.2f″％(ps.sh.gc(opt_seq)＊100)
fasta_classes.write(opt_title，opt_seq，seqfile)
def check_sequence(org_seq，opt_seq，sh):
opt_aa＝sh.translate(opt_seq)
if org_seq<>opt_aa:
print″Optimization error！Mutation introduced！″
sys.exit()
##### Main Program #####
infile＝sys.argv[1] # FASTA file of sequences to optimize，this is now
a protein
statfile＝sys.argv[2] # Pass in a stats file created by
syngene_builder.py
seqoutfile＝sys.argv[3] # Pass in a file name to write output sequences
to
seqfile＝open(seqoutfile，′a′)
sh＝SeqHandler()
fp＝fasta_classes.FastaParser(infile)
for seq in fp:
org_seq＝seq.sequence.upper()
print ″ Generating initial optimum nucleotide sequence...″
ps＝syngene_classes.PSeqGenerator(org_seq，statfile，order＝5，
segmentsize＝7)
check_sequence(org_seq，ps.sequence()，sh)
print″ Optimizing junctions and low spots...″
ss＝syngene_classes.SeqScrubber(ps.sequence()，statfile，order＝5)
ss.optimize()
reopt_seq＝ss.sequence()
print″ Attempting to scrub spurious ORFs...″
unscrubbed＝ss.scrub_orfs()
if unscrubbed:
print″ Warning:％s unscrubbable ORF(s)remain.″％(unscrubbed)
check_sequence(org_seq，ss.sequence()，sh)
print″ Attempting to scrub disallowed sites...″
scrubbed＝ss.scrub_sites()
check_sequence(org_seq，ss.sequence()，sh)
print″ Final cleanup in progress...″
ss.cleanup()
check_sequence(org_seq，ss.sequence()，sh)
opt_seq＝ss.sequence()
opt_title＝seq.title+′_DNA′
show_sequence(opt_title，opt_seq，seqfile)
seqfile.close()
实施例3.使用核苷酸序列生成优化的基因序列
以下实施例显示了通过使用实施例2的这些算法以生成一个优化基因序列的一个简化的日志文件。多个日志记录被删除并且用“数据未显示”替换，它简单地指明进行了类似的步骤但没有在这个实施例中列出。在该实施例中显示的序列列于表1中。
优化序列axmi004_original...
开始第1轮优化。
在位置1222处更新，寡聚物是TGAGA，初始得分是0.032，delta得分是4.664。
在位置403处更新，寡聚物是TGAGA，初始得分是0.032，delta得分是4.134。
(数据未显示)
在位置1138处更新，寡聚物是ACTTC，初始得分是0.127，delta得分是0.134。
第1轮完成。序列得分是70.241
(数据未显示)
开始第6轮优化。
在位置1561处更新，寡聚物是TGAGG，初始得分是0.091，delta得分是0.058。
第6轮完成。序列得分是233.679
开始第7轮优化。
第7轮完成。序列得分是233.679
优化完成。
尝试剔除假ORFs...
第1轮，当前ORF计数是10
最大假ORF是354个氨基酸，从核苷酸824到1886。
发现的解决方案：TGCTG在位置1439处，delta是-0.204。
(数据未显示)
第31轮，当前ORF计数是2
最大假ORF是75个氨基酸，从核苷酸406到631。
发现的解决方案：TGAGA在位置580处，delta是-0.037。
尝试剔除不允许的位置...
第1轮，当前位置计数是11。
尝试剔除位点hindⅢ的首次发生，序列AAGCTT。
为位置AAGCTT没有发现匹配
(数据未显示)
尝试剔除位点BbsI_RC的首次发生，序列GTCTTC。
在位置1152到1158发现位点。
发现的解决方案：CGTGT在位置1151处，delta是-0.144最终清除进行中...
执行清除扫描...
在位置1340处改变，寡聚物是CAAAG，delta是0.636
(数据未显示)
优化的序列：axmi004_original_opt_full
初始得分：-127.61优化得分：219.30
初始GC百分比：34.92优化的GC百分比：55.59
尝试GC下降到0.500...
扫描序列的可能改变...
在位置1284处更新，寡聚物是GGATC，delta是-0.012，新GC百分比是55.54。
在位置1625处更新，寡聚物是AAGAT，delta是-0.024，新GC百分比是55.48。
(数据未显示)
在位置155处更新，寡聚物是ATTTG，delta是-0.363，新GC百分比是49.97。
最终清除进行中...
执行清除扫描...
在位置1571处改变，寡聚物是TGGGC，delta是0.387
(数据未显示)
优化的序列：axmi004_original_opt_0.5
初始得分：-127.61优化的得分：202.61
初始GC百分比：34.92优化的GC百分比：49.71
实施例4.使用基于氨基酸序列的初步优化步骤生成优化的基因序列
以下实施例显示了通过使用实施例2的算法以便通过使用经翻译的氨基酸序列进行初步优化的步骤来生成一个优化的基因序列而产生的简化日志文件。已经删除了多个日志记录并且用“数据未显示”替换，它简单地指明进行了类似的步骤但没有列于这个实施例中。在这个实施例中显示的序列列于表1中。
生成初始最佳核苷酸序列...
在位置0处简并序列MSELKGK
在位置7处简并序列FKKSTNR
在位置14处简并序列TCCLLKI
(数据未显示)
在位置623处简并序列EFIPVE
优化结合处以及低点...
开始第1轮优化。
在位置1213处更新，寡聚物是CCTTC，初始得分是0.227，delta得分是2.248。
在位置1048处更新，寡聚物是ACCGC，初始得分是0.027，delta得分是2.066。
在位置1111处更新，寡聚物是CCAAC，初始得分是0.188，delta得分是1.600。
(数据未显示)
在位置1129处更新，寡聚物是GGGAC，初始得分是-0.030，delta得分是0.032。
第1轮完成。序列得分是235.396
开始第2轮优化。
在位置1630处更新，寡聚物是ACAGG，初始得分是-0.049，delta得分是0.270。
在位置328处更新，寡聚物是TCGAG，初始得分是0.126，delta得分是0.159。
在位置1054处更新，寡聚物是TCACC，初始得分是0.137，delta得分是0.042。
第2轮完成，序列得分是235.867
开始第3轮优化。
在位置1056处更新，寡聚物是ACCTC，初始得分是0.196，delta得分是0.044。
第3轮完成。序列得分是235.911
开始第4轮优化。
第4轮完成。序列得分是235.911
优化完成。
尝试剔除假ORFs...
第1轮，当前ORF计数是11
最大假ORF是354个氨基酸，核苷酸从824到1886。
发现的解决方案：在位置1439处的TGCTG，delta是-0.700。
第2轮，当前ORF计数是12
最大假ORF是306个氨基酸，核苷酸从1653到735。
发现的解决方案：在位置1167处的TCAAA，delta是-0.742。
(数据未显示)
第25轮，当前ORF计数是2
最大假ORF是75个氨基酸，核苷酸从406到631。
发现的解决方案：在位置580处的TGAGA，delta是-0.037。
尝试剔除不允许位点...
第1轮，当前位置计数是11。
尝试剔除位点HindⅢ的首次发生，序列AAGCTT。
对位点AAGCTT没有发现匹配
(数据未显示)
尝试剔除位点BsmBl的首次发生，序列CGTCTC。
在位置194到200发现位点。
发现的解决方案：在位置196处的TCAGC，delta是-0.439第2轮，当前位置计数是10。
尝试剔除位点HindⅢ的首次发生，序列AAGCTT。
对位置AAGCTT没有发现匹配
(数据未显示)
尝试剔除位置PstI的首次发生，序列CTGCAG。
在位置1188到1194发现位点。
发现的解决方案：在位置1189处的TCCAG，delta是-0.344
(数据未显示)
第11轮，当前位置计数是1。
(数据未显示)
尝试位置剔除位点BbsI_RC的首次发生，序列GTCTTC。
在位置243到249发现位点。
发现的解决方案：在位置241处的TCGTG，delta是-0.493
最终清除进行中...
执行清除扫描...
在位置629处改变，寡聚物是AATCA，delta是0.567
(数据未显示)
在位置1852处改变，寡聚物是TTTAT，delta是0.112
执行清除扫描...
优化的序列：axmi004_DNA
优化的得分：222.40
优化的GC百分比：57.02
表1.在实施例3和4中描述的序列。
在本说明书中提及的所有出版物和专利申请都是表明本发明所属领域内的普通技术人员的水平的。所有出版物和专利申请均通过引用以相同的程度并入本文，就如同每单个的出版物或专利申请是明确地并且单独地指出通过引用并入本文。
尽管出于理解清楚的目的通过阐明和实施例在一定程度上详细地说明了以上发明，但是显而易见的是可以在所附的权利要求的范围内进行某些改变和修饰。
序列表
<110>Daniel J.Tomso
<120>合成基因设计的计算方法
<130>45600/363732
<150>60/978,729
<151>2007-10-09
<160>60
<170>FastSEQ for Windows版本4.0
<210>1
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>1
aatgaa 6
<210>2
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>2
attta 5
<210>3
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>3
aaaaa 5
<210>4
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>4
aaaac 5
<210>5
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>5
aaaag 5
<210>6
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>6
ttttt 5
<210>7
<211>15
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>7
agtgcaagta cgtaa 15
<210>8
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>8
aataaa 6
<210>9
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>9
aatatt 6
<210>10
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>10
aaccaa 6
<210>11
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>11
atacta 6
<210>12
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>12
gataaa 6
<210>13
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>13
atataa 6
<210>14
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>14
ataaaa 6
<210>15
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>15
attaat 6
<210>16
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>16
aataat 6
<210>17
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>17
aataag 6
<210>18
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>18
aatcaa 6
<210>19
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>19
atgaaa 6
<210>20
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>20
aagcat 6
<210>21
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>21
atacat 6
<210>22
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>22
aaaata 6
<210>23
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>23
attaaa 6
<210>24
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>24
aattaa 6
<210>25
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>25
aataca 6
<210>26
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>26
cataaa 6
<210>27
<211>6
<212>RNA
<213>人工序列
<220>
<223>能够形成发夹环的序列
<400>27
cuucgg 6
<210>28
<211>7
<212>RNA
<213>人工序列
<220>
<223>能够形成发夹环的序列
<400>28
ucuucgg 7
<210>29
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>29
tgaga 5
<210>30
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>30
acttc 5
<210>31
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>31
tgagg 5
<210>32
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>32
tgctg 5
<210>33
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>33
aagctt 6
<210>34
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>34
gtcttc 6
<210>35
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>35
ggtgt 5
<210>36
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>36
caaag 5
<210>37
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>37
ggatc 5
<210>38
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>38
aagat 5
<210>39
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>39
atttg 5
<210>40
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>40
tgggc 5
<210>41
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>41
ccttc 5
<210>42
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>42
accgc 5
<210>43
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>43
ccaac 5
<210>44
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>44
gggac 5
<210>45
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>45
acagg 5
<210>46
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>46
tcgag 5
<210>47
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>47
tcacc 5
<210>48
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>48
acctc 5
<210>49
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>49
tcaaa 5
<210>50
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>50
cgtctc 6
<210>51
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>51
tcagc 5
<210>52
<211>6
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>52
ctgcag 6
<210>53
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>53
tccag 5
<210>54
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>54
tcgtg 5
<210>55
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>55
aatca 5
<210>56
<211>5
<212>DNA
<213>人工序列
<220>
<223>寡核苷酸序列
<400>56
tttat 5
<210>57
<211>7
<212>PRT
<213>人工序列
<220>
<223>肽段
<400>57
Met Ser Glu Leu Lys Gly Lys
1 5
<210>58
<211>7
<212>PRT
<213>人工序列
<220>
<223>肽段
<400>58
Phe Lys Lys Ser Thr Asn Arg
1 5
<210>59
<211>7
<212>PRT
<213>人工序列
<220>
<223>肽段
<400>59
Thr Cys Cys Leu Leu Lys Ile
1 5
<210>60
<211>6
<212>PRT
<213>人工序列
<220>
<223>肽段
<400>60
Glu Phe Ile Pro Val Glu
1 5
机译： 合成基因设计的计算方法
机译： 合成基因设计的计算方法
机译： 合成基因设计的计算方法
