poseigen-oyster 0.0.4__tar.gz

poseigen_oyster-0.0.4/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright 2025 Husam Abdulnabi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

poseigen_oyster-0.0.4/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.3
+Name: poseigen_oyster
+Version: 0.0.4
+Summary: The basics for Poseigen software
+License: MIT
+Author: Husam Abdulnabi
+Author-email: husam.abdulnabi@gmail.com
+Maintainer: Husam Abdulnabi
+Maintainer-email: husam.abdulnabi@gmail.com
+Requires-Python: >=3.12
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development
+Classifier: Programming Language :: Python :: 3
+Requires-Dist: kneed
+Requires-Dist: numpy
+Requires-Dist: poseigen_chisel
+Requires-Dist: poseigen_seaside
+Requires-Dist: poseigen_trident
+Requires-Dist: scikit-learn
+Requires-Dist: torch
+Project-URL: Homepage, https://github.com/husam94/poseigen_oyster
+Description-Content-Type: text/markdown
+
+Will do

poseigen_oyster-0.0.4/README.md

@@ -0,0 +1 @@
+Will do

poseigen_oyster-0.0.4/pyproject.toml

@@ -0,0 +1,65 @@
+
+
+[build-system]
+
+requires = ["setuptools", 
+			"numpy",
+      "torch", 
+      "poseigen_seaside", 
+      "poseigen_trident",
+      "poseigen_chisel", 
+      "scikit-learn", 
+      "kneed"			
+			]
+
+[project]
+
+name = "poseigen_oyster"
+
+version = "0.0.4"
+
+requires-python = ">=3.12"
+
+description = "The basics for Poseigen software"
+
+readme = "README.md"
+
+license = "MIT"
+
+license-files = ["LICEN[CS]E.*"]
+
+keywords = []
+
+authors = [{ name = "Husam Abdulnabi", email = "husam.abdulnabi@gmail.com" }]
+
+maintainers = [
+  { name = "Husam Abdulnabi", email = "husam.abdulnabi@gmail.com" },
+]
+
+classifiers = [
+  # How mature is this project? Common values are
+  #   3 - Alpha
+  #   4 - Beta
+  #   5 - Production/Stable
+  "Development Status :: 3 - Alpha",
+
+  # Indicate who your project is intended for
+  "Intended Audience :: Developers",
+  "Topic :: Software Development",
+
+  "Programming Language :: Python :: 3",
+  
+]
+
+dependencies = [
+  "numpy",
+  "torch", 
+  "poseigen_seaside", 
+  "poseigen_trident",
+  "poseigen_chisel", 
+  "scikit-learn", 
+  "kneed"		
+  ]
+
+[project.urls]
+"Homepage" = "https://github.com/husam94/poseigen_oyster"

poseigen_oyster-0.0.4/src/poseigen_oyster/__init__.py

@@ -0,0 +1,2 @@
+from .model import *
+from .analysis import *

poseigen_oyster-0.0.4/src/poseigen_oyster/analysis.py

@@ -0,0 +1,451 @@
+
+# These functions are specific to EXACT OYSTER
+
+import numpy as np
+
+import poseigen_chisel as chis
+import poseigen_trident.utils as tu
+
+import torch
+import torch.nn as nn
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+from sklearn.cluster import KMeans, AgglomerativeClustering
+from kneed import KneeLocator
+
+
+def SigContrib(model, inp, 
+                   sub_model = None, 
+                   batchsize = 256):
+
+    shapo = inp.shape #the 2nd dimension is always the number of sigs. 
+    num_sigs = shapo[1]
+
+    if isinstance(model, list) is False: model = [model]
+    #if sub_model is None: sub_model = ''
+
+    lk = len(inp)
+
+    fullbatches = lk // batchsize
+    rem = lk % batchsize
+
+    fins = []
+
+    for fb in np.arange(fullbatches + (rem > 0)):
+
+        fo = fb*batchsize
+        batch = inp[fo:fo + batchsize]
+
+        fin = []
+
+        for mo in model: 
+
+            if isinstance(mo, str): mo = tu.LoadTorch(mo)
+
+            if sub_model is not None: mo = getattr(mo, sub_model)
+            
+            with torch.no_grad(): 
+                mo.eval()
+
+                ger = 0 if isinstance(mo.O[0], nn.Conv2d) else 1
+
+                Dweight = mo.O[ger].weight
+                Dweight = torch.unsqueeze(Dweight, 0)
+
+                x = torch.FloatTensor(batch).to(device)
+
+                x = mo.Reflect(x)
+                x = mo.kE(x)
+                x = mo.AntiReflect(x)
+                x = mo.P(x)
+                
+                x = torch.unsqueeze(x, axis = 1)
+                x = x * Dweight
+                x = torch.squeeze(torch.sum(x, axis = 3))
+
+                xshapo = x.shape
+                x = torch.sum(x.reshape(xshapo[0], num_sigs, xshapo[-1] // num_sigs), -1)
+
+                fin.append(x.cpu().detach().numpy())
+
+        fin = np.mean(np.stack(fin), axis = 0)
+        fins.append(fin) 
+        
+    return np.vstack(fins)
+
+
+
+def kmer_contrib(model, inp, sub_model = None, 
+                 joint = False, chunk = False): 
+    
+    # The inp is (kmer, *kmer shape)
+
+    mo = tu.LoadTorch(model) if isinstance(model, str) else model
+    
+    if sub_model is not None: mo = getattr(mo, sub_model)
+
+    shapo = inp.shape
+
+    with torch.no_grad(): 
+        mo.eval()
+
+        ger = 0 if isinstance(mo.O[0], nn.Conv2d) else 1
+
+        Dweight = mo.O[ger].weight
+        Dweight = torch.unsqueeze(Dweight, 0)
+
+        x = inp
+
+        if joint: x = mo.Reflect(x)
+
+        x = mo.kE(x)
+        x = torch.unsqueeze(x, axis = 1)
+
+        #---------------------------
+
+        if isinstance(mo.P, nn.Identity) is False:
+            P_ck = mo.P.kernel_size[0]
+            x = x / P_ck
+
+        #---------------------------
+
+        x = x * Dweight
+
+        if chunk: 
+            xshapo = x.shape
+            x = x.reshape(xshapo[0], xshapo[1], shapo[1], xshapo[2] // shapo[1], *xshapo[-2:])
+            x = torch.sum(x, axis = 3)
+        else: 
+            x = torch.sum(x, axis = -3)
+
+        if joint: x = torch.unsqueeze(torch.mean(x, axis = -1), dim= -1)
+
+    return x.cpu().detach().numpy()
+
+
+def kmer_contrib_multi(model, inp, sub_model = None, 
+                       joint = False, chunk = False, batchsize = 256):
+
+    lk = len(inp)
+    fullbatches = lk // batchsize
+    rem = lk % batchsize
+
+    kc_args = {'sub_model': sub_model, 'joint': joint, 'chunk': chunk}
+
+    fins = []
+
+    for fb in np.arange(fullbatches + (rem > 0)):
+
+        fo = fb*batchsize
+
+        batch = inp[fo:fo + batchsize]
+
+        batch_t = torch.FloatTensor(batch).to(device)
+
+        if isinstance(model, list): 
+            fin = [kmer_contrib(m, batch_t, ** kc_args) for m in model]
+            fin = np.mean(np.stack(fin), axis = 0)
+        else: 
+            fin = kmer_contrib(model, batch_t, ** kc_args)
+        
+        fins.append(fin)
+    
+    fins = np.vstack(fins)
+
+    return fins
+
+
+
+def kppm_contrib(model, kppm,
+                 
+                 sub_model = None, joint = False, chunk = False,
+                 score_mode = 'recipeuc',
+                 
+                 random_seqs = 10000, unique = True, 
+                 scoreweight = True, batchsize = 256):
+
+    # generates kmers from the ppm and scores them to the final output
+    # ppm must be the same size as the model head 
+
+    kmers = chis.kmersFromPPM(kppm, num = random_seqs, unique = unique)
+    kmers_OHE = np.expand_dims(chis.Seqs2OHE(kmers), axis = 1)
+
+    fins = kmer_contrib_multi(model, kmers_OHE, sub_model = sub_model,
+                              joint = joint, chunk = chunk, batchsize = batchsize)
+
+    if scoreweight: 
+
+        kmers_scored = chis.PWMScorer(np.squeeze(kmers_OHE, axis = 1), 
+                                      kppm, revcomp = joint,
+                                      score_mode = score_mode).reshape(-1, 1, 1, 1)
+                
+        out = np.sum((fins * kmers_scored), axis = 0) / np.sum(kmers_scored)
+        
+    else: out = np.mean(fins, axis = 0)
+
+    return out
+
+def contrib_perpos(contribs, oys_dict, submodel = None):
+   
+    # this function takes your contribution per position block 
+    # and expands it to the whole sequence
+
+    # center in this case means that the model used padding for pooling. 
+
+    #contribs shape: (subjects, pos, *)
+
+    #-------------------------------
+
+    submodel = '' if submodel is None else submodel + '_'
+
+    seq_len = oys_dict[submodel + 'dim_i'][1]
+    k_len, P_ck = [oys_dict[submodel + xoo] for xoo in ['kE_k', 'P_ck']]
+    P_center = oys_dict['P_center']
+
+    #-------------------------------
+
+    dim_kE_length = seq_len - k_len + 1
+
+    needed = P_ck - (dim_kE_length % P_ck)
+    pad2add = (needed // 2) if P_center else 0
+
+    P_length = int(np.ceil(dim_kE_length / P_ck))
+
+    #-------------------------------------------
+
+    firstpos = P_ck - pad2add
+    midpos = P_ck 
+    lastpos = dim_kE_length - firstpos - (midpos * (P_length - 2))
+
+    contribs_perpos = [np.repeat(contribs[:, [0]], firstpos, axis = 1),
+                       *[np.repeat(contribs[:, x], midpos, axis = 1) for x in [np.arange(P_length)[1:-1]]], 
+                       np.repeat(contribs[:, [-1]], lastpos, axis = 1)]
+        
+    contribs_perpos = np.concatenate(contribs_perpos, axis = 1)
+                    
+    return contribs_perpos
+
+
+def sppm_contrib(kppm_contribs_exp, kppm_idxs):
+
+    #This returns a list since they can be different sizes. 
+
+    sizo = kppm_contribs_exp.shape[1]
+
+    outs = []
+    for idxs in kppm_idxs: 
+
+        lex = len(idxs)
+        sex = sizo-lex
+
+        contrib_cuts = np.array([kppm_contribs_exp[do, ido: sex+ido] 
+                                 for ido, do in enumerate(idxs)])
+
+        outs.append(np.sum(contrib_cuts, axis = 0))
+    
+    return outs
+
+def sppm_avgrevcomp(sppm_contribs): 
+
+    # This averages the revcomps, flips the revcomp first tho 
+    # sppm_contribs are of shape (contribs, len) 
+    lex = len(sppm_contribs)
+    idxs = np.arange(lex)
+    sppm1 = [sppm_contribs[ido] for ido in idxs[:lex//2]]
+    sppm2 = [sppm_contribs[ido][::-1] for ido in idxs[lex//2:]]
+
+    sppm_avg = [(s1 + s2) / 2 for s1, s2 in zip(sppm1, sppm2)]
+
+    return sppm_avg
+
+def contrib_fill(contribs, seq_len, 
+                 fill_with = np.nan, fill_center = True): 
+
+    # contribs is an array or a list 
+    expocons = []
+    for cont in contribs: 
+        diffx = seq_len - len(cont)
+
+        diffx1 = diffx // 2 if fill_center else 0
+        diffx2 = diffx - diffx1
+
+        contexp = np.hstack([np.full(diffx1, fill_with), cont, np.full(diffx2, fill_with)])
+                             
+        expocons.append(contexp)
+    
+    return np.array(expocons)
+
+
+
+def kmer_cluster(inp, H_size,
+                 num_clusters = 10, sample = None,
+                 chunk = False, 
+                 cluster_mode = [KMeans, {}]):
+
+    sig_win_rs = tu.TridentWindow(inp, H_size)
+
+    num_sigs = sig_win_rs.shape[1]
+    
+    lk = len(sig_win_rs)
+    
+    if isinstance(sample, int): 
+        rando = np.random.choice(np.arange(lk), sample, replace=False)
+    else: rando = np.arange(lk)
+
+    if chunk:  #EACH SIGNAL INDIVIDUAL CLUSTER
+
+        clustod = []
+        for i in np.arange(num_sigs):
+
+            sig = sig_win_rs[:, i].reshape(lk, -1)
+            sig_samp = sig[rando]
+            clust = cluster_mode[0](n_clusters = num_clusters, **cluster_mode[1])
+            clust.fit(sig_samp)
+            clustod.append(clust.predict(sig))
+            print(f'finished: {i}')
+        
+        clustod = np.stack(clustod, axis = 1)
+    
+    else: 
+        clust = cluster_mode[0](n_clusters = num_clusters, **cluster_mode[1])
+        clust.fit(sig_win_rs[rando].reshape(len(rando), -1))
+        clustod = clust.predict(sig_win_rs.reshape(lk, -1))
+    
+    return clustod
+
+
+def cluster_centroids(signal, clusters):
+    #signal is a (n, *) shape and clusters is a 1dim
+    return np.stack([np.mean(signal[clusters == b], axis = 0) for b in np.unique(clusters)])
+
+
+def cluster_refine(signal, clusters, S = 1, return_newcents = False):
+                   
+    #uses agglomerative clsutering on centroids 
+    # S is sensitivity for kneed. 
+
+    clust1_uni = np.unique(clusters)
+
+    cents1 = cluster_centroids(signal, clusters)
+    model1 = AgglomerativeClustering(distance_threshold=0, n_clusters=None)
+    model1 = model1.fit(cents1.reshape(len(cents1), -1))
+
+    kn = KneeLocator(np.arange(len(model1.distances_)), model1.distances_, 
+                     S = S, 
+                     curve='convex', direction='increasing')
+    kno = kn.knee
+
+    model2 = AgglomerativeClustering(distance_threshold=model1.distances_[kno], n_clusters=None)
+    clust2 = model2.fit_predict(cents1.reshape(len(cents1), -1)) #you have a lst the length of unique clusters
+
+
+    clust2_uni = np.unique(clust2)
+    
+    print(f'from {len(clust1_uni)} to {len(clust2_uni)}')
+
+    clust2_sepidx = [clust1_uni[clust2 == u] for u in clust2_uni] #This now tells you which of the original clusters belongs to each new cluster 
+
+
+    newclust = np.ones(len(clusters))
+    for u,g in zip(clust2_uni, clust2_sepidx): 
+        for h in g:
+            newclust[clusters == h] = u 
+    
+
+    newcents = cluster_centroids(signal, newclust)
+
+    return (newclust, newcents) if return_newcents else newclust
+
+
+def centroid_contrib(wins, contribs, clusters, 
+                     weighted = True, score_mode = 'recipeuc', 
+                     chunk = False, return_centroids = False):
+    #wins shape = (number, signal, k, 1)
+    #contribs shape = (number, signal, pos, 1)
+    #clusters shape = (number, signal) 
+
+    #this gets the centroids and their score per position 
+
+    num_sigs = contribs.shape[1]
+
+    centroids_all = []
+    contrib_cents_all = []
+
+    if chunk:
+
+        for s in np.arange(num_sigs): 
+
+            centroids = []
+            contrib_cents = []
+
+            clus = np.unique(clusters[:, s])
+
+            for c in clus: 
+
+                wino = wins[:, s][clusters[:, s] == c] #this is now (num, k, 1) 
+
+                centroid = np.mean(wino, axis = 0) #this is now (k, 1)
+                centroids.append(centroid)
+
+                contribo = contribs[:, s][clusters[:, s] == c] #this is now (num, pos, 1) 
+
+                if weighted:
+
+                    centroid_exp = np.expand_dims(centroid, axis = 0)
+
+                    if score_mode == 'dot': 
+                        scores = np.sum(wino * centroid_exp, axis = (-1, -2))
+
+                    elif score_mode == 'recipeuc': 
+                        scores = 1 / (np.sum(np.abs(wino-centroid_exp)**2, axis = (-1, -2))**(1/2))
+                    
+                    scores = scores.reshape(-1, 1, 1)
+                    
+                    contrib_cent = np.sum(contribo * scores, axis = 0) / np.sum(scores)
+                
+                else: 
+
+                    contrib_cent = np.mean(contribo, axis = 0)
+                
+                contrib_cents.append(contrib_cent)
+
+            centroids_all.append(np.stack(centroids)) 
+            contrib_cents_all.append(np.stack(contrib_cents))
+    
+    else: 
+
+        for c in np.unique(clusters): 
+
+            wino = wins[clusters == c] #this is now (num, s, k, 1) 
+
+            centroid = np.mean(wino, axis = 0) #this is now (s, k, 1)
+            centroids_all.append(centroid)
+
+            contribo = contribs[clusters == c, 0] #this is now (num, pos, 1)
+
+            if weighted: #Compare the wino to the centroid. Closer one is weighted more. 
+
+                centroid_exp = np.expand_dims(centroid, axis = 0)
+
+                if score_mode == 'dot': 
+                    scores = np.sum(wino * centroid_exp, axis = (-1, -2, -3))
+
+                elif score_mode == 'recipeuc': 
+                    scores = 1 / (np.sum(np.abs(wino-centroid_exp)**2, axis = (-1, -2, -3))**(1/2))
+                
+                scores = scores.reshape(-1, 1, 1)
+                
+                contrib_cent = np.sum(contribo * scores, axis = 0) / np.sum(scores)
+            
+            else: 
+
+                contrib_cent = np.mean(contribo, axis = 0)
+            
+            contrib_cents_all.append(contrib_cent)
+        
+        centroids_all, contrib_cents_all = [np.array(x) 
+                                            for x in [centroids_all, contrib_cents_all]]
+
+    return (centroids_all, contrib_cents_all) if return_centroids else contrib_cents_all
+
+

poseigen_oyster-0.0.4/src/poseigen_oyster/model.py

@@ -0,0 +1,309 @@
+import numpy as np
+
+import poseigen_seaside.basics as se
+import poseigen_trident.utils as tu
+import poseigen_trident.prongs as tp
+
+import torch
+import torch.nn as nn
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+
+class  Oyster(nn.Module): 
+        
+    def __init__(self, 
+                 dim_i = (1,249,4), dim_f = (1,1,1),
+                 incl_only = None,
+
+                 DS = False, DS_wwp_func = nn.AvgPool2d, DS_act = False,
+
+                 
+                 kE_k = 15, kE_cf_m = 100, kE_cf_ns = 1, 
+                 kE_ck_base = 4, kE_OneByOne = False, 
+                 kE_ck_grouped = False, 
+
+                 P_ck = None, P_center = False,
+                 
+                 O_mods = None, O_mods_ns = 0.3,
+                 O_cf_pu_m = None, O_cf_ns = 1, 
+                 O_ck_base = None, O_pool_k2s = 0.5,
+                 O_pool_func = None, O_actb4pool = True, 
+                 O_dropout = 0, O_bias = False,
+                           
+                 activations = nn.ReLU(), activation_f = None, 
+                 batchnorm = 'before'):
+        
+        super(Oyster, self).__init__()
+
+
+        # 25.01.25 OCU Version A
+        # "Head" == now "kE" for k-mer Embedding
+        # "C" == now "P" for position
+        # "D" == now "O" for output
+        #kE_cf_m == the filter multiplier. 
+        #P_center == whether to add padding to center things or not. 
+
+        #25.03.28: added incl_only which uses only a subset of the data. 
+
+
+        self.incl_only = None
+        if incl_only is not None: 
+            if len(incl_only) == dim_i[0]: pass
+            else: 
+                dim_i = (len(incl_only), dim_i[1], dim_i[2])
+                self.incl_only = incl_only
+
+                print(dim_i)
+            
+        
+
+
+        self.Reflect = tu.ReflectLayer(dims = [-1, -2]) if DS else nn.Identity()
+        
+        kE_cf_f = kE_cf_m * dim_i[0]
+
+        if (dim_i[1] - kE_k + 1) < dim_f[1]: kE_k = dim_i[1] - dim_f[1] + 1
+
+        dim_i_ref = (dim_i[0], dim_i[1], dim_i[2]*2) if DS else dim_i
+        dim_kE_width = 2 if DS else 1
+        dim_kE_length = dim_i[1] - kE_k + 1
+        dim_kE = (kE_cf_f, dim_kE_length, dim_kE_width)
+
+        kE_Prong_args = {'dim_i': dim_i_ref, 'dim_f': dim_kE,
+                         'mods': 0, 'mods_ns': 0,    
+                         'cf_i': None, 'cf_ns': kE_cf_ns, 'ck_base': kE_ck_base,
+                         'doublestranded': DS, 'OneByOne': kE_OneByOne,        
+                         'ck_grouped': kE_ck_grouped,
+                         'activations': activations, 'activation_f': None,
+                         'batchnorm': batchnorm, 'dropout': None, 'bias': True,
+                         'out': False}
+        
+        self.kE = nn.Sequential(*tp.Prong_X(**kE_Prong_args))
+
+        ################################################################
+
+        anti_ref_layers = [tu.FlipLayer(), tu.WWPLayer(func = DS_wwp_func)]
+        if DS_act: anti_ref_layers.append(activations)
+
+        self.AntiReflect = nn.Sequential(*anti_ref_layers) if DS else nn.Identity()
+
+        ###########################################################################################
+
+        P_func = nn.AvgPool2d
+
+        if P_ck == None: P_ck = 0
+        if P_ck == 0:
+            # Now this means do not pool. 
+            self.P, P_length = (nn.Identity(), dim_kE_length)
+        
+        elif P_ck > 1: 
+
+            needed = P_ck - (dim_kE_length % P_ck)
+            pad2add = (needed // 2) if P_center else 0
+
+            self.P = P_func((P_ck, 1), stride = (P_ck,1), 
+                            padding = (pad2add, 0), ceil_mode = True, divisor_override = P_ck)
+            
+            P_length = int(np.ceil(dim_kE_length / P_ck))
+        
+        else: # means its 1, means we global pool
+
+            self.P = P_func((dim_kE_length, 1), stride = (1,1), 
+                            padding = (0, 0), ceil_mode = True, divisor_override = dim_kE_length)
+
+            P_length = 1
+
+        if O_cf_pu_m == None: O_cf_pu_m = 0
+        O_cf_pu = O_cf_pu_m * kE_cf_f if O_cf_pu_m != 0 else None
+
+        O_Prong_args = {'dim_i': (kE_cf_f, P_length, 1), 'dim_f': dim_f,
+                        'mods': O_mods, 'mods_ns': O_mods_ns,    
+                        'cf_i': None, 'cf_pu': O_cf_pu,
+                        'cf_ns': O_cf_ns, 'ck_base': O_ck_base, 
+                        'doublestranded': False, 
+                        'ck_dynamic': False, 'skip_first_ck': False,
+                        'pool_k2s': O_pool_k2s, 'pool_func': O_pool_func, 'actb4pool': O_actb4pool,
+                        'activations': nn.ReLU(), 'activation_f': None,
+                        'batchnorm': batchnorm, 'dropout': O_dropout, 'bias': O_bias,
+                        'out': True}
+    
+        self.O = nn.Sequential(*tp.Prong_Y(**O_Prong_args))
+
+        self.actf = nn.Identity() if activation_f is None else activation_f
+        
+    def forward(self, x):
+
+        if self.incl_only is not None: x = x[:, self.incl_only]
+
+        x = self.Reflect(x)
+        x = self.kE(x)
+        x = self.AntiReflect(x)
+        x = self.P(x)
+        x = self.O(x)
+        x = self.actf(x)
+        
+        return x
+    
+
+
+    oys_args = {'dim_i': (1,249,4), 'dim_f': (1,1,1),
+                'DS': False, 'DS_wwp_func': nn.AvgPool2d, 'DS_act': False,
+                'incl_only': None,
+
+                'kE_k': 15, 'kE_cf_m': 100, 'kE_cf_ns': 1, 
+                'kE_ck_base': 4, 'kE_OneByOne': False, 
+                'kE_ck_grouped': False, 
+                
+                'P_ck': None, 'P_center': False,
+                
+                'O_mods': None, 'O_mods_ns': 0.3,
+                'O_cf_pu_m': None, 'O_cf_ns': 1, 
+                'O_ck_base': None, 'O_pool_k2s': 0.5,
+                'O_pool_func': None, 'O_actb4pool': True, 'O_dropout': 0,
+                
+                'activations': nn.ReLU(), 'activation_f': None, 
+                'batchnorm': 'before'}
+    
+
+
+
+class DualOyster(nn.Module): 
+    
+    def __init__(self, 
+                 dim_f = (1,1,1),
+
+                 A_dim_i = (1,249,4), A_DS = False, A_incl_only = None,
+                 A_kE_k = 15, A_kE_cf_m = 100, A_kE_cf_ns = 1, 
+                 A_kE_ck_base = 4, A_kE_OneByOne = False, 
+                 A_kE_ck_grouped = False, 
+                 A_P_ck = None,
+
+                 use_B = True,
+
+                 B_dim_i = (1,249,4), B_DS = False, B_incl_only = None,
+                 B_kE_k = 15, B_kE_cf_m = 100, B_kE_cf_ns = 1, 
+                 B_kE_ck_base = 4, B_kE_OneByOne = False, 
+                 B_kE_ck_grouped = False, 
+                 B_P_ck = None,
+
+                DS_wwp_func = nn.AvgPool2d, DS_act = False,
+                P_center = False,
+                O_mods = None, O_mods_ns = 0.3,
+                O_cf_pu_m = None, O_cf_ns = 1, 
+                O_ck_base = None, O_pool_k2s = 0.5,
+                O_pool_func = None, O_actb4pool = True, O_dropout = 0,
+                 activations = nn.ReLU(), activation_f = None, 
+                 batchnorm = 'before'):
+        
+        super(DualOyster, self).__init__()
+
+        oys_shared_args = {'dim_f': dim_f,
+                           'DS_wwp_func': DS_wwp_func, 'DS_act': DS_act,
+                           'P_center': P_center,
+                           'O_mods': O_mods, 'O_mods_ns': O_mods_ns,
+                           'O_cf_pu_m': O_cf_pu_m, 'O_cf_ns': O_cf_ns, 
+                           'O_ck_base': O_ck_base, 'O_pool_k2s': O_pool_k2s,
+                           'O_pool_func': O_pool_func, 'O_actb4pool': O_actb4pool, 'O_dropout': O_dropout,
+                           'activations': activations,'batchnorm': batchnorm}
+        
+
+        oys_A_args = {'dim_i': A_dim_i, 'DS': A_DS, 'incl_only': A_incl_only,
+                   'kE_k': A_kE_k, 'kE_cf_m': A_kE_cf_m, 'kE_cf_ns': A_kE_cf_ns, 
+                   'kE_ck_base': A_kE_ck_base, 'kE_OneByOne': A_kE_OneByOne, 
+                   'kE_ck_grouped': A_kE_ck_grouped, 
+                   'P_ck': A_P_ck,
+                   **oys_shared_args}
+        
+        self.OysterA = Oyster(**oys_A_args)
+
+        self.use_B = use_B 
+        if B_incl_only is not None: 
+            if len(B_incl_only) == 0: 
+                self.use_B = False 
+                B_incl_only = None
+        if self.use_B == False: print('NOT USING!!!!')  
+
+        
+
+        oys_B_args = {'dim_i': B_dim_i, 'DS': B_DS, 'incl_only': B_incl_only,
+                   'kE_k': B_kE_k, 'kE_cf_m': B_kE_cf_m, 'kE_cf_ns': B_kE_cf_ns, 
+                   'kE_ck_base': B_kE_ck_base, 'kE_OneByOne': B_kE_OneByOne, 
+                   'kE_ck_grouped': B_kE_ck_grouped, 
+                   'P_ck': B_P_ck,
+                   **oys_shared_args}
+        
+        self.OysterB = Oyster(**oys_B_args)
+
+        self.FA = activation_f if activation_f != None else nn.Identity()
+
+    def forward(self, x1, x2): 
+
+        x1 = self.OysterA(x1)
+        x2 = self.OysterB(x2) if self.use_B else 0
+
+        return self.FA(x1 + x2)
+
+
+    
+
+DualOyster_BaseDict = {'A_dim_i': [[(1,249,4)],'cat'], #Set as a single dim_i
+                      'B_dim_i': [[(11,40,1)],'cat'], #Set as a single dim_i
+                      'dim_f': [[(2,1,1)],'cat'], #Set as a single dim_f
+
+                      'A_kE_ck_grouped': [[True, False], 'cat'], #NEED TO BE SET
+                      'A_DS': [[True, False], 'cat'],
+                      'A_kE_k': [[12, 20], 'int'], 
+                      'A_kE_cf_m': [[50, 150], 'int'],
+                      'A_kE_cf_ns': [[1, 1.1, 1.2], 'cat'],
+                      'A_kE_ck_base': [[4, 5, 6, 7, 8, None], 'cat'], 
+                      'A_kE_OneByOne': [[True, False], 'cat'],
+                      'A_P_ck': [[6, 20], 'int'],
+                      
+                      'B_kE_ck_grouped': [[True, False], 'cat'], #NEED TO BE SET
+                      'B_DS': [[True, False], 'cat'],
+                      'B_kE_k': [[12, 20], 'int'], 
+                      'B_kE_cf_m': [[50, 150], 'int'],
+                      'B_kE_cf_ns': [[1, 1.1, 1.2], 'float'],
+                      'B_kE_ck_base': [[4, 5, 6, 7, 8, None], 'cat'], 
+                      'B_kE_OneByOne': [[True, False], 'cat'],
+                      'B_P_ck': [[6, 20], 'int'],
+
+
+                      
+                      'DS_wwp_func': [[nn.MaxPool2d], 'cat'],
+                      'DS_act': [[False], 'cat'],
+
+                      'P_center': [[True, False], 'cat'],
+
+                      'O_mods': [[None], 'cat'],
+                      'O_mods_ns': [[0.5], 'cat'],
+                      'O_cf_pu_m': [[None], 'cat'],
+                      'O_cf_ns': [[1, 1.1, 1.2], 'cat'],
+                      'O_ck_base': [[None], 'cat'],
+                      'O_pool_k2s': [[0, 0.5], 'cat'],
+                      'O_pool_func': [[nn.MaxPool2d], 'cat'],
+                      'O_actb4pool': [[True], 'cat'],
+                      'O_dropout': [[0, 0.2], 'cat'],
+
+
+                      'activations': [[nn.ReLU(), nn.LeakyReLU()], 'cat'],
+                      'batchnorm': [[None, 'before'], 'cat']}
+
+
+def Reset_DualOyster(dualoyster):
+    #ds consists of a "conv" and a "dense" module. Need to go through each one, see if its a conv and reset if so. 
+
+
+    for oyster in [dualoyster.OysterA, dualoyster.OysterB]: 
+        lke, los = len(oyster.kE), len(oyster.O)
+
+        for i in np.arange(lke): 
+            if isinstance(oyster.kE[i], nn.Conv2d): 
+                oyster.kE[i].reset_parameters()
+        
+        for i in np.arange(los): 
+            if isinstance(oyster.O[i], nn.Conv2d): 
+                oyster.O[i].reset_parameters()
+        print('done reset mod')
+
+    return dualoyster