DNA_Pattern_recognition.py

import numpy as np
import tensorflow as tf
from tensorflow import keras
from sklearn.model_selection import train_test_split
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.preprocessing.sequence import pad_sequences

# Example DNA sequences and labels (1 = contains pattern, 0 = does not)
dna_sequences = ["ATCGTTAG", "GGCATCGA", "TTAGGCAT", "CCGTAAGC", "AGCTTAGG"]
labels = [1, 0, 1, 0, 1]

# Convert DNA sequences to one-hot encoding
def one_hot_encode(seq):
    mapping = {'A': [1, 0, 0, 0], 'T': [0, 1, 0, 0], 'C': [0, 0, 1, 0], 'G': [0, 0, 0, 1]}
    return np.array([mapping[nuc] for nuc in seq])

encoded_sequences = np.array([one_hot_encode(seq) for seq in dna_sequences])
encoded_sequences = pad_sequences(encoded_sequences, padding='post', dtype='float32')

# Train-test split
X_train, X_test, y_train, y_test = train_test_split(encoded_sequences, labels, test_size=0.2, random_state=42)

# Positional Encoding
def positional_encoding(seq_length, embed_dim):
    pos = np.arange(seq_length)[:, np.newaxis]
    i = np.arange(embed_dim)[np.newaxis, :]
    angle_rates = 1 / np.power(10000, (2 * (i // 2)) / np.float32(embed_dim))
    angle_rads = pos * angle_rates
    angle_rads[:, 0::2] = np.sin(angle_rads[:, 0::2])
    angle_rads[:, 1::2] = np.cos(angle_rads[:, 1::2])
    return tf.convert_to_tensor(angle_rads, dtype=tf.float32)

# Transformer Block for Feature Extraction
class TransformerBlock(keras.layers.Layer):
    def __init__(self, embed_dim, num_heads, ff_dim, rate=0.5):
        super(TransformerBlock, self).__init__()
        self.att = keras.layers.MultiHeadAttention(num_heads=num_heads, key_dim=embed_dim)
        self.ffn = keras.Sequential([
            keras.layers.Dense(ff_dim, activation="leaky_relu", kernel_regularizer=keras.regularizers.l2(0.01)),
            keras.layers.BatchNormalization(),
            keras.layers.Dense(embed_dim, kernel_regularizer=keras.regularizers.l2(0.01)),
        ])
        self.layernorm1 = keras.layers.LayerNormalization(epsilon=1e-6)
        self.layernorm2 = keras.layers.LayerNormalization(epsilon=1e-6)
        self.dropout1 = keras.layers.Dropout(rate)
        self.dropout2 = keras.layers.Dropout(rate)

    def call(self, inputs, training=False):
        attn_output = self.att(inputs, inputs, inputs)
        attn_output = self.dropout1(attn_output, training=training)
        out1 = self.layernorm1(inputs + attn_output)
        ffn_output = self.ffn(out1)
        ffn_output = self.dropout2(ffn_output, training=training)
        return self.layernorm2(out1 + ffn_output)

# Model Parameters
embed_dim = 32
num_heads = 4
ff_dim = 64

# Define the Transformer Model for DNA Pattern Recognition
inputs = keras.Input(shape=(X_train.shape[1], 4))
pos_encoding = positional_encoding(X_train.shape[1], embed_dim)
x = keras.layers.Dense(embed_dim, kernel_regularizer=keras.regularizers.l2(0.01))(inputs)  # Project input to embedding dimension
x += pos_encoding  # Add positional encoding
x = TransformerBlock(embed_dim, num_heads, ff_dim)(x)
x = keras.layers.GlobalAveragePooling1D()(x)
x = keras.layers.Dense(128, activation="leaky_relu", kernel_regularizer=keras.regularizers.l2(0.01))(x)
x = keras.layers.Dropout(0.5)(x)  # Increased dropout to reduce overfitting
x = keras.layers.Dense(64, activation="leaky_relu", kernel_regularizer=keras.regularizers.l2(0.01))(x)
x = keras.layers.BatchNormalization()(x)
x = keras.layers.Dense(1, activation="sigmoid")(x)

model = keras.Model(inputs=inputs, outputs=x)

# Compile the model with reduced learning rate
model.compile(optimizer=keras.optimizers.Adam(learning_rate=0.0005), loss='binary_crossentropy', metrics=['accuracy'])

# Train the model with increased batch size
model.fit(X_train, np.array(y_train), epochs=15, batch_size=8, validation_data=(X_test, np.array(y_test)))

# Evaluate the model
eval_results = model.evaluate(X_test, np.array(y_test))
print("Test Accuracy:", eval_results[1])