eqcctpro 0.6.4__tar.gz → 0.6.6__tar.gz

{eqcctpro-0.6.4 → eqcctpro-0.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eqcctpro
-Version: 0.6.4
+Version: 0.6.6
 Summary: EQCCTPro: A powerful seismic event detection toolkit
 Author-email: Constantinos Skevofilax <constantinos.skevofilax@austin.utexas.edu>, Victor Salles <victor.salles@beg.utexas.edu>
 Project-URL: Homepage, https://pypi.org/project/eqcctpro/

eqcctpro-0.6.6/eqcctpro/__init__.py

@@ -0,0 +1,14 @@
+# eqcctpro/__init__.py
+from .functionality import (
+    RunEQCCTPro,
+    EvaluateSystem,
+    OptimalCPUConfigurationFinder,
+    OptimalGPUConfigurationFinder,
+)
+__all__ = [
+    "RunEQCCTPro",
+    "EvaluateSystem",
+    "OptimalCPUConfigurationFinder",
+    "OptimalGPUConfigurationFinder",
+]
+__version__ = "0.6.6"

eqcctpro-0.6.6/eqcctpro/eqcct_tf_models.py

@@ -0,0 +1,407 @@
+import warnings
+import absl.logging
+import numpy as np
+import tensorflow as tf 
+from io import StringIO
+from contextlib import redirect_stdout
+from silence_tensorflow import silence_tensorflow
+
+# Silence TensorFlow logging
+absl.logging.set_verbosity(absl.logging.ERROR)
+tf.get_logger().setLevel('ERROR')
+tf.autograph.set_verbosity(0)
+warnings.filterwarnings("ignore")
+silence_tensorflow()
+
+w1 = 6000
+w2 = 3
+drop_rate = 0.2
+stochastic_depth_rate = 0.1
+
+positional_emb = False
+conv_layers = 4
+num_classes = 1
+input_shape = (w1, w2)
+num_classes = 1
+input_shape = (6000, 3)
+image_size = 6000  # We'll resize input images to this size
+patch_size = 40  # Size of the patches to be extract from the input images
+num_patches = (image_size // patch_size)
+projection_dim = 40
+
+num_heads = 4
+transformer_units = [
+    projection_dim,
+    projection_dim,
+]  # Size of the transformer layers
+transformer_layers = 4
+
+def recall(y_true, y_pred):
+    true_positives = tf.keras.backend.sum(tf.keras.backend.round(tf.keras.backend.clip(y_true * y_pred, 0, 1)))
+    possible_positives = tf.keras.backend.sum(tf.keras.backend.round(tf.keras.backend.clip(y_true, 0, 1)))
+    recall = true_positives / (possible_positives + tf.keras.backend.epsilon())
+    return recall
+
+
+def precision(y_true, y_pred):
+    true_positives = tf.keras.backend.sum(tf.keras.backend.round(tf.keras.backend.clip(y_true * y_pred, 0, 1)))
+    predicted_positives = tf.keras.backend.sum(tf.keras.backend.round(tf.keras.backend.clip(y_pred, 0, 1)))
+    precision = true_positives / (predicted_positives + tf.keras.backend.epsilon())
+    return precision
+
+ 
+def f1(y_true, y_pred):
+    precisionx = precision(y_true, y_pred)
+    recallx = recall(y_true, y_pred)
+    return 2*((precisionx*recallx)/(precisionx+recallx+tf.keras.backend.epsilon()))
+
+
+def wbceEdit( y_true, y_pred) :
+    ms = tf.keras.backend.mean(tf.keras.backend.square(y_true-y_pred)) 
+    ssim = 1-tf.reduce_mean(tf.image.ssim(y_true,y_pred,1.0))
+    return (ssim + ms)
+
+class Patches(tf.keras.layers.Layer):
+    def __init__(self, patch_size, **kwargs):
+        super(Patches, self).__init__()
+        self.patch_size = patch_size
+
+    def get_config(self):
+        config = super().get_config().copy()
+        config.update({
+            'patch_size' : self.patch_size, 
+            
+        })
+        
+        return config
+        
+    def call(self, images):
+        batch_size = tf.shape(images)[0]
+        patches = tf.image.extract_patches(
+            images=images,
+            sizes=[1, self.patch_size, 1, 1],
+            strides=[1, self.patch_size, 1, 1],
+            rates=[1, 1, 1, 1],
+            padding="VALID",
+        )
+        patch_dims = patches.shape[-1]
+        patches = tf.reshape(patches, [batch_size, -1, patch_dims])
+        return patches
+    
+class PatchEncoder(tf.keras.layers.Layer):
+    def __init__(self, num_patches, projection_dim, **kwargs):
+        super(PatchEncoder, self).__init__()
+        self.num_patches = num_patches
+        self.projection = tf.keras.layers.Dense(units=projection_dim)
+        self.position_embedding = tf.keras.layers.Embedding(
+            input_dim=num_patches, output_dim=projection_dim
+        )
+
+    def get_config(self):
+        config = super().get_config().copy()
+        config.update({
+            'num_patches' : self.num_patches, 
+            'projection_dim' : projection_dim, 
+            
+        })
+        
+        return config
+    
+    def call(self, patch):
+        positions = tf.range(start=0, limit=self.num_patches, delta=1)
+        encoded = self.projection(patch) + self.position_embedding(positions)
+        
+        #print(patch,positions)
+        #temp = self.position_embedding(positions)
+        #temp = tf.reshape(temp,(1,int(temp.shape[0]),int(temp.shape[1])))
+        #encoded = tf.keras.layers.Add()([self.projection(patch), temp])
+        #print(temp,encoded)
+        
+        return encoded
+    
+
+# Referred from: github.com:rwightman/pytorch-image-models.
+class StochasticDepth(tf.keras.layers.Layer):
+    def __init__(self, drop_prop, **kwargs):
+        super(StochasticDepth, self).__init__(**kwargs)
+        self.drop_prob = drop_prop
+
+    def call(self, x, training=None):
+        if training:
+            keep_prob = 1 - self.drop_prob
+            shape = (tf.shape(x)[0],) + (1,) * (len(tf.shape(x)) - 1)
+            random_tensor = keep_prob + tf.random.uniform(shape, 0, 1)
+            random_tensor = tf.floor(random_tensor)
+            return (x / keep_prob) * random_tensor
+        return x
+    
+
+class PreLoadGeneratorTest(tf.keras.utils.Sequence):
+    def __init__(self, list_IDs, inp_data, batch_size=32, norm_mode='std',
+                 dim=None, n_channels=None, dtype=np.float32, **kwargs):
+        self.batch_size  = int(batch_size)
+        self.list_IDs    = list_IDs
+        self.inp_data    = inp_data
+        self.norm_mode   = norm_mode
+        self.dtype       = dtype
+
+        # Infer input shape if not provided
+        sample = np.array(next(iter(self.inp_data.values())))
+        if dim is None or n_channels is None:
+            if sample.ndim == 2:
+                # Expect (T, C) like (6000, 3)
+                self.dim = (int(sample.shape[0]),)
+                self.n_channels = int(sample.shape[1])
+            elif sample.ndim == 1:
+                # Fallback to (T, 1)
+                self.dim = (int(sample.shape[0]),)
+                self.n_channels = 1
+            else:
+                raise ValueError(f"Unsupported sample shape: {sample.shape}")
+        else:
+            self.dim = tuple(dim)
+            self.n_channels = int(n_channels)
+
+        self.on_epoch_end()
+
+    def __len__(self):
+        return int(np.ceil(len(self.list_IDs) / self.batch_size))
+
+    def __getitem__(self, index):
+        start_idx = index * self.batch_size
+        end_idx   = min((index + 1) * self.batch_size, len(self.list_IDs))
+        indexes   = self.indexes[start_idx:end_idx]
+        list_IDs_temp = [self.list_IDs[k] for k in indexes]
+
+        X = self.__data_generation(list_IDs_temp)
+
+        # Keras tolerates a short last batch; we already sized X to the true count.
+        return {'input': X.astype(self.dtype, copy=False)}
+
+    def on_epoch_end(self):
+        self.indexes = np.arange(len(self.list_IDs))
+
+    def __data_generation(self, list_IDs_temp):
+        batch_count = len(list_IDs_temp)
+        X = np.empty((batch_count, self.dim[0], self.n_channels), dtype=self.dtype)
+
+        for i, ID in enumerate(list_IDs_temp):
+            # Use the correct storage and make a writable float32 copy
+            data = np.array(self.inp_data[ID], dtype=self.dtype, copy=True)
+
+            data = self._normalize(data, self.norm_mode)
+            # Ensure (T, C) layout
+            if data.ndim == 1:
+                data = data[:, None]
+            if data.shape != (self.dim[0], self.n_channels):
+                raise ValueError(f"Sample {ID} has shape {data.shape}, expected {(self.dim[0], self.n_channels)}")
+            X[i] = data
+
+        return X
+
+    def _normalize(self, data, mode='max'):
+        # Out-of-place ops to be safe even if upstream hands us a read-only view
+        data = data - np.mean(data, axis=0, keepdims=True)
+        if mode == 'max':
+            max_data = np.max(data, axis=0, keepdims=True)
+            max_data[max_data == 0] = 1
+            data = data / max_data
+        elif mode == 'std':
+            std_data = np.std(data, axis=0, keepdims=True)
+            std_data[std_data == 0] = 1
+            data = data / std_data
+        return data
+
+def load_eqcct_model(input_modelP, input_modelS, log_file="results/logs/model.log"):
+    # print(f"[{datetime.now()}] Loading EQCCT model.")
+    
+    # with open(log_file, mode="w", buffering=1) as log:
+    #     log.write(f"*** Loading the model ...\n")
+
+    # Model CCT
+    inputs = tf.keras.layers.Input(shape=input_shape,name='input')
+
+    featuresP = create_cct_modelP(inputs)
+    featuresP = tf.keras.layers.Reshape((6000,1))(featuresP)
+
+    featuresS = create_cct_modelS(inputs)
+    featuresS = tf.keras.layers.Reshape((6000,1))(featuresS)
+
+    logitp  = tf.keras.layers.Conv1D(1,  15, strides =(1), padding='same',activation='sigmoid', kernel_initializer='he_normal',name='picker_P')(featuresP)
+    logits  = tf.keras.layers.Conv1D(1,  15, strides =(1), padding='same',activation='sigmoid', kernel_initializer='he_normal',name='picker_S')(featuresS)
+
+    modelP = tf.keras.models.Model(inputs=[inputs], outputs=[logitp])
+    modelS = tf.keras.models.Model(inputs=[inputs], outputs=[logits])
+
+    model = tf.keras.models.Model(inputs=[inputs], outputs=[logitp,logits])
+
+    summary_output = StringIO()
+    with redirect_stdout(summary_output):
+        model.summary()
+    # log.write(summary_output.getvalue())
+    # log.write('\n')
+
+    sgd = tf.keras.optimizers.Adam()
+    model.compile(optimizer=sgd,
+                loss=['binary_crossentropy','binary_crossentropy'],
+                metrics=['acc',f1,precision, recall])    
+    
+    modelP.load_weights(input_modelP)
+    modelS.load_weights(input_modelS)
+
+    # log.write(f"*** Loading is complete!")
+
+    return model
+
+def convF1(inpt, D1, fil_ord, Dr):
+
+    channel_axis = 1 if tf.keras.backend.image_data_format() == "channels_first" else -1
+    #filters = inpt._keras_shape[channel_axis]
+    filters = int(inpt.shape[-1])
+    
+    #infx = tf.keras.layers.Activation(tf.nn.gelu')(inpt)
+    pre = tf.keras.layers.Conv1D(filters,  fil_ord, strides =(1), padding='same',kernel_initializer='he_normal')(inpt)
+    pre = tf.keras.layers.BatchNormalization()(pre)    
+    pre = tf.keras.layers.Activation(tf.nn.gelu)(pre)
+    
+    #shared_conv = tf.keras.layers.Conv1D(D1,  fil_ord, strides =(1), padding='same')
+    
+    inf = tf.keras.layers.Conv1D(filters,  fil_ord, strides =(1), padding='same',kernel_initializer='he_normal')(pre)
+    inf = tf.keras.layers.BatchNormalization()(inf)    
+    inf = tf.keras.layers.Activation(tf.nn.gelu)(inf)
+    inf = tf.keras.layers.Add()([inf,inpt])
+    
+    inf1 = tf.keras.layers.Conv1D(D1,  fil_ord, strides =(1), padding='same',kernel_initializer='he_normal')(inf)
+    inf1 = tf.keras.layers.BatchNormalization()(inf1)  
+    inf1 = tf.keras.layers.Activation(tf.nn.gelu)(inf1)    
+    encode = tf.keras.layers.Dropout(Dr)(inf1)
+
+    return encode
+
+
+def mlp(x, hidden_units, dropout_rate):
+    for units in hidden_units:
+        x = tf.keras.layers.Dense(units, activation=tf.nn.gelu)(x)
+        #x = tf.keras.layers.Dense(units, activation='relu')(x)
+        x = tf.keras.layers.Dropout(dropout_rate)(x)
+    return x
+
+
+def create_cct_modelP(inputs):
+
+    inputs1 = convF1(inputs,  10, 11, 0.1)
+    inputs1 = convF1(inputs1, 20, 11, 0.1)
+    inputs1 = convF1(inputs1, 40, 11, 0.1)
+    
+    inputreshaped = tf.keras.layers.Reshape((6000,1,40))(inputs1)
+    # Augment data.
+    #augmented = data_augmentation(inputs)
+    # Create patches.
+    patches = Patches(patch_size)(inputreshaped)
+    # Encode patches.
+    encoded_patches = PatchEncoder(num_patches, projection_dim)(patches)
+    #print('done')
+        
+    # Calculate Stochastic Depth probabilities.
+    dpr = [x for x in np.linspace(0, stochastic_depth_rate, transformer_layers)]
+
+    # Create multiple layers of the Transformer block.
+    for i in range(transformer_layers):
+        #encoded_patches = convF1(encoded_patches, 40,11, 0.1)
+        # Layer normalization 1.
+        x1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)(encoded_patches)
+
+        # Create a multi-head attention layer.
+        attention_output = tf.keras.layers.MultiHeadAttention(
+            num_heads=num_heads, key_dim=projection_dim, dropout=0.1
+        )(x1, x1)
+        #attention_output = convF1(attention_output, 40,11, 0.1)
+    
+
+        # Skip connection 1.
+        attention_output = StochasticDepth(dpr[i])(attention_output)
+        x2 = tf.keras.layers.Add()([attention_output, encoded_patches])
+
+        # Layer normalization 2.
+        x3 = tf.keras.layers.LayerNormalization(epsilon=1e-6)(x2)
+
+        # MLP.
+        x3 = mlp(x3, hidden_units=transformer_units, dropout_rate=0.1)
+
+        # Skip connection 2.
+        x3 = StochasticDepth(dpr[i])(x3)
+        encoded_patches = tf.keras.layers.Add()([x3, x2])
+
+    # Apply sequence pooling.
+    representation = tf.keras.layers.LayerNormalization(epsilon=1e-6)(encoded_patches)
+    #print(representation)
+    ''' 
+    attention_weights = tf.nn.softmax(tf.keras.layers.Dense(1)(representation), axis=1)
+    weighted_representation = tf.matmul(
+        attention_weights, representation, transpose_a=True
+    )
+    weighted_representation = tf.squeeze(weighted_representation, -2)
+
+    return weighted_representation
+    '''
+    return representation
+
+
+def create_cct_modelS(inputs):
+
+    inputs1 = convF1(inputs,  10, 11, 0.1)
+    inputs1 = convF1(inputs1, 20, 11, 0.1)
+    inputs1 = convF1(inputs1, 40, 11, 0.1)
+    
+    inputreshaped = tf.keras.layers.Reshape((6000,1,40))(inputs1)
+    # Augment data.
+    #augmented = data_augmentation(inputs)
+    # Create patches.
+    patches = Patches(patch_size)(inputreshaped)
+    # Encode patches.
+    encoded_patches = PatchEncoder(num_patches, projection_dim)(patches)
+    #print('done')
+        
+    # Calculate Stochastic Depth probabilities.
+    dpr = [x for x in np.linspace(0, stochastic_depth_rate, transformer_layers)]
+
+    # Create multiple layers of the Transformer block.
+    for i in range(transformer_layers):
+        encoded_patches = convF1(encoded_patches, 40,11, 0.1)
+        # Layer normalization 1.
+        x1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)(encoded_patches)
+
+        # Create a multi-head attention layer.
+        attention_output = tf.keras.layers.MultiHeadAttention(
+            num_heads=num_heads, key_dim=projection_dim, dropout=0.1
+        )(x1, x1)
+        attention_output = convF1(attention_output, 40,11, 0.1)
+    
+
+        # Skip connection 1.
+        attention_output = StochasticDepth(dpr[i])(attention_output)
+        x2 = tf.keras.layers.Add()([attention_output, encoded_patches])
+
+        # Layer normalization 2.
+        x3 = tf.keras.layers.LayerNormalization(epsilon=1e-6)(x2)
+
+        # MLP.
+        x3 = mlp(x3, hidden_units=transformer_units, dropout_rate=0.1)
+
+        # Skip connection 2.
+        x3 = StochasticDepth(dpr[i])(x3)
+        encoded_patches = tf.keras.layers.Add()([x3, x2])
+
+    # Apply sequence pooling.
+    representation = tf.keras.layers.LayerNormalization(epsilon=1e-6)(encoded_patches)
+    #print(representation)
+    ''' 
+    attention_weights = tf.nn.softmax(tf.keras.layers.Dense(1)(representation), axis=1)
+    weighted_representation = tf.matmul(
+        attention_weights, representation, transpose_a=True
+    )
+    weighted_representation = tf.squeeze(weighted_representation, -2)
+
+    return weighted_representation
+    '''
+    return representation