Prompt Injection Py Script.py

from google.colab import drive
drive.mount('/content/drive/')

import pandas as pd
import numpy as np

df_train = pd.read_csv('/content/drive/MyDrive/LLM_Injcetion/train.csv')
df_train.head()

df_test = pd.read_csv('/content/drive/MyDrive/LLM_Injcetion/test.csv')
df_test.head()

df = pd.concat([df_train, df_test], ignore_index=True)

#df.to_csv('/content/drive/MyDrive/LLM_Injcetion/combined.csv', index=False)

df.head()

import re
def remove_between_square_brackets(text):
    return re.sub(r'\[[^]]*\]', '', text)

def denoise_text(text):
    text = remove_between_square_brackets(text)
    return text

def remove_special_characters(text, remove_digits=True):
    pattern = r'[^a-zA-Z0-9\s]' if remove_digits else r'[^a-zA-Z\s]'
    text = re.sub(pattern, '', text)
    return text

def preprocess_text(text):
    text = denoise_text(text)
    text = remove_special_characters(text)
    return text

df['preprocessed_text'] = df['text'].apply(preprocess_text)

df.head()

import matplotlib.pyplot as plt
label_counts = df['label'].value_counts()
plt.figure(figsize=(8, 6))
ax = label_counts.plot(kind='bar')
plt.title('Distribution of Labels')
plt.xlabel('Label')
plt.ylabel('Count')
plt.xticks(rotation=0)
for i, count in enumerate(label_counts):
    ax.text(i, count + 0.5, str(count), ha='center', va='bottom')

from sklearn.model_selection import train_test_split
X = df['preprocessed_text'].values
y = df['label'].values
X_train, X_test, Y_train, Y_test = train_test_split(X, y, test_size=0.2, random_state=42)

from sklearn.feature_extraction.text import TfidfVectorizer
vec = TfidfVectorizer()
vec.fit(X_train)
x_train=vec.transform(X_train)
x_test=vec.transform(X_test)

from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
from sklearn.linear_model import LogisticRegression
from sklearn.naive_bayes import MultinomialNB
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
import xgboost as xgb
models = {
    "Logistic Regression": LogisticRegression(),
    "Multinomial Naive Bayes": MultinomialNB(),
    "Support Vector Machine": SVC(),
    "Random Forest": RandomForestClassifier(),
    "AdaBoost": AdaBoostClassifier(),
    "XGBoost": xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss'),
    "K-Nearest Neighbors": KNeighborsClassifier(),
    "Decision Tree": DecisionTreeClassifier(),
    "Gradient Boosting": GradientBoostingClassifier()
}

# Initialize a list to store results
results = []

# Evaluate each model
for model_name, model in models.items():
    model.fit(x_train, Y_train)
    Y_pred = model.predict(x_test)
    accuracy = accuracy_score(Y_test, Y_pred)
    precision = precision_score(Y_test, Y_pred, average='binary')
    recall = recall_score(Y_test, Y_pred, average='binary')
    f1 = f1_score(Y_test, Y_pred, average='binary')

    results.append({
        "Model": model_name,
        "Accuracy": accuracy,
        "Precision": precision,
        "Recall": recall,
        "F1 Score": f1
    })

# Convert results to DataFrame
results_df = pd.DataFrame(results)

# Save results to a CSV file
#results_df.to_csv('/content/drive/MyDrive/LLM_Injcetion/model_results.csv', index=False)

# Display the results DataFrame
print(results_df)

from gensim.models import Word2Vec
import nltk
nltk.download('punkt')

# Tokenize the text data
tokenized_text = [nltk.word_tokenize(text) for text in X_train]

# Train Word2Vec model
word2vec_model = Word2Vec(tokenized_text, vector_size=100, window=5, min_count=1, workers=4)

# Save Word2Vec model
word2vec_model.save('/content/drive/MyDrive/LLM_Injcetion/word2vec.model')

tokenized_text_train = [nltk.word_tokenize(text) for text in X_train]
tokenized_text_test = [nltk.word_tokenize(text) for text in X_test]

def text_to_word_embeddings(tokenized_text):
    embeddings = [word2vec_model.wv[word] for word in tokenized_text if word in word2vec_model.wv]
    if embeddings:
        return np.mean(embeddings, axis=0)
    else:
        return np.zeros(word2vec_model.vector_size)

x_train = np.array([text_to_word_embeddings(text) for text in tokenized_text_train])
x_test = np.array([text_to_word_embeddings(text) for text in tokenized_text_test])

# Define models to evaluate
models = {
    "Logistic Regression": LogisticRegression(),
    "Support Vector Machine": SVC(),
    "Random Forest": RandomForestClassifier(),
    "AdaBoost": AdaBoostClassifier(),
    "XGBoost": xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss'),
    "K-Nearest Neighbors": KNeighborsClassifier(),
    "Decision Tree": DecisionTreeClassifier(),
    "Gradient Boosting": GradientBoostingClassifier()
}

# Initialize a list to store results
results = []

# Evaluate each model
for model_name, model in models.items():
    model.fit(x_train, Y_train)
    Y_pred = model.predict(x_test)
    accuracy = accuracy_score(Y_test, Y_pred)
    precision = precision_score(Y_test, Y_pred, average='binary')
    recall = recall_score(Y_test, Y_pred, average='binary')
    f1 = f1_score(Y_test, Y_pred, average='binary')

    results.append({
        "Model": model_name,
        "Accuracy": accuracy,
        "Precision": precision,
        "Recall": recall,
        "F1 Score": f1
    })

# Convert results to DataFrame
results_df = pd.DataFrame(results)

# Save results to a CSV file
results_df.to_csv('/content/drive/MyDrive/LLM_Injcetion/word2vec_model_results.csv', index=False)

# Display the results DataFrame
print(results_df)

df.head()

from sklearn.feature_extraction.text import CountVectorizer
# Extract features and labels
X = df['preprocessed_text'].values
Y = df['label'].values

# Split the dataset into training and testing sets
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=42)

# Transform the text data using CountVectorizer (Bag of Words)
vectorizer = CountVectorizer()
x_train = vectorizer.fit_transform(X_train)
x_test = vectorizer.transform(X_test)

# Define models to evaluate
models = {
    "Logistic Regression": LogisticRegression(),
    "Multinomial Naive Bayes": MultinomialNB(),
    "Support Vector Machine": SVC(),
    "Random Forest": RandomForestClassifier(),
    "AdaBoost": AdaBoostClassifier(),
    "XGBoost": xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss'),
    "K-Nearest Neighbors": KNeighborsClassifier(),
    "Decision Tree": DecisionTreeClassifier(),
    "Gradient Boosting": GradientBoostingClassifier()
}

# Initialize a list to store results
results = []

# Evaluate each model
for model_name, model in models.items():
    model.fit(x_train, Y_train)
    Y_pred = model.predict(x_test)
    accuracy = accuracy_score(Y_test, Y_pred)
    precision = precision_score(Y_test, Y_pred, average='binary')
    recall = recall_score(Y_test, Y_pred, average='binary')
    f1 = f1_score(Y_test, Y_pred, average='binary')

    results.append({
        "Model": model_name,
        "Accuracy": accuracy,
        "Precision": precision,
        "Recall": recall,
        "F1 Score": f1
    })

# Convert results to DataFrame
results_df = pd.DataFrame(results)

# Save results to a CSV file
results_df.to_csv('/content/drive/MyDrive/LLM_Injcetion/bow_model_results.csv', index=False)

# Display the results DataFrame
print(results_df)

from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, Dense, Dropout, Conv1D, MaxPooling1D, GlobalMaxPooling1D
from tensorflow.keras.optimizers import Adam
X = df['preprocessed_text'].values
Y = df['label'].values

# Split the dataset into training and testing sets
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=42)

# Tokenize the text data and create sequences
tokenizer = Tokenizer(num_words=10000)
tokenizer.fit_on_texts(X_train)

x_train = tokenizer.texts_to_sequences(X_train)
x_test = tokenizer.texts_to_sequences(X_test)

# Pad the sequences
vocab = len(tokenizer.word_index) + 1
maxlen = 100
x_train = pad_sequences(x_train, padding='post', maxlen=maxlen)
x_test = pad_sequences(x_test, padding='post', maxlen=maxlen)

# Build a more complex model
emb_dim = 100
model = Sequential()
model.add(Embedding(input_dim=vocab, output_dim=emb_dim, input_length=maxlen))
model.add(Conv1D(filters=128, kernel_size=5, activation='relu'))
model.add(MaxPooling1D(pool_size=2))
model.add(Conv1D(filters=128, kernel_size=5, activation='relu'))
model.add(GlobalMaxPooling1D())
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(32, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(1, activation='sigmoid'))

model.compile(optimizer=Adam(learning_rate=0.001), loss='binary_crossentropy', metrics=['accuracy'])

# Train the model
history = model.fit(x_train, Y_train, epochs=10, verbose=1, validation_split=0.2, batch_size=64)

# Evaluate the model
loss, accuracy = model.evaluate(x_test, Y_test, verbose=1)
print(f'Test Accuracy: {accuracy}')

# Plot the training and validation accuracy and loss
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='train_accuracy')
plt.plot(history.history['val_accuracy'], label='val_accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()
plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='train_loss')
plt.plot(history.history['val_loss'], label='val_loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.show()

from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, Dense, Dropout, Conv1D, MaxPooling1D, GlobalMaxPooling1D
from tensorflow.keras.optimizers import Adam
import matplotlib.pyplot as plt
import nltk
import tensorflow as tf
from transformers import BertTokenizer, TFBertForSequenceClassification
import tensorflow as tf
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Conv1D, MaxPooling1D, GlobalMaxPooling1D
from sklearn.model_selection import train_test_split
from transformers import BertTokenizer, TFBertModel
X = df['preprocessed_text'].values
Y = df['label'].values

# Split the dataset into training and testing sets
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=42)

# Load BERT tokenizer and BERT model for embeddings
bert_tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
bert_model = TFBertModel.from_pretrained('bert-base-uncased')

# Tokenize and pad sequences for BERT
def tokenize_bert(texts, max_len=100):
    input_ids, attention_masks = [], []
    for text in texts:
        encoded = bert_tokenizer.encode_plus(text, add_special_tokens=True, max_length=max_len, pad_to_max_length=True, return_attention_mask=True)
        input_ids.append(encoded['input_ids'])
        attention_masks.append(encoded['attention_mask'])
    return np.array(input_ids), np.array(attention_masks)

x_train_ids, x_train_masks = tokenize_bert(X_train, max_len=100)
x_test_ids, x_test_masks = tokenize_bert(X_test, max_len=100)

# Create BERT embeddings
def create_bert_embeddings(input_ids, attention_masks):
    embeddings = bert_model(input_ids, attention_mask=attention_masks)[0]
    return embeddings

train_embeddings = create_bert_embeddings(x_train_ids, x_train_masks)
test_embeddings = create_bert_embeddings(x_test_ids, x_test_masks)

# Build a more complex model using BERT embeddings
emb_dim = train_embeddings.shape[-1]
maxlen = train_embeddings.shape[1]

model = Sequential()
model.add(tf.keras.layers.Input(shape=(maxlen, emb_dim)))
model.add(Conv1D(filters=128, kernel_size=5, activation='relu'))
model.add(MaxPooling1D(pool_size=2))
model.add(Conv1D(filters=128, kernel_size=5, activation='relu'))
model.add(GlobalMaxPooling1D())
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(32, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(1, activation='sigmoid'))

model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001), loss='binary_crossentropy', metrics=['accuracy'])

# Train the model
history = model.fit(train_embeddings, Y_train, epochs=10, batch_size=32, validation_split=0.2)

# Evaluate the model
loss, accuracy = model.evaluate(test_embeddings, Y_test, verbose=1)
print(f'Test Accuracy: {accuracy}')

# Plot the training and validation accuracy and loss
import matplotlib.pyplot as plt

plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='train_accuracy')
plt.plot(history.history['val_accuracy'], label='val_accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()
plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='train_loss')
plt.plot(history.history['val_loss'], label='val_loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.show()

from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Conv1D, MaxPooling1D, GlobalMaxPooling1D, SimpleRNN, LSTM, Bidirectional, Embedding, Input
from sklearn.model_selection import train_test_split
from transformers import BertTokenizer, TFBertModel
# Define function to build and train model
def build_and_train_model(model_name, model):
    print(f'Training {model_name} model...')
    model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001), loss='binary_crossentropy', metrics=['accuracy'])
    history = model.fit(train_embeddings, Y_train, epochs=10, batch_size=32, validation_split=0.2)
    loss, accuracy = model.evaluate(test_embeddings, Y_test, verbose=1)
    print(f'{model_name} Test Accuracy: {accuracy}')

    # Plot the training and validation accuracy and loss
    plt.figure(figsize=(12, 4))
    plt.subplot(1, 2, 1)
    plt.plot(history.history['accuracy'], label='train_accuracy')
    plt.plot(history.history['val_accuracy'], label='val_accuracy')
    plt.xlabel('Epoch')
    plt.ylabel('Accuracy')
    plt.legend()
    plt.title(f'{model_name} Accuracy')
    plt.subplot(1, 2, 2)
    plt.plot(history.history['loss'], label='train_loss')
    plt.plot(history.history['val_loss'], label='val_loss')
    plt.xlabel('Epoch')
    plt.ylabel('Loss')
    plt.legend()
    plt.title(f'{model_name} Loss')
    plt.show()

# CNN Model
cnn_model = Sequential()
cnn_model.add(Input(shape=(train_embeddings.shape[1], train_embeddings.shape[2])))
cnn_model.add(Conv1D(filters=128, kernel_size=5, activation='relu'))
cnn_model.add(MaxPooling1D(pool_size=2))
cnn_model.add(Conv1D(filters=128, kernel_size=5, activation='relu'))
cnn_model.add(GlobalMaxPooling1D())
cnn_model.add(Dense(64, activation='relu'))
cnn_model.add(Dropout(0.5))
cnn_model.add(Dense(32, activation='relu'))
cnn_model.add(Dropout(0.5))
cnn_model.add(Dense(1, activation='sigmoid'))

build_and_train_model('CNN', cnn_model)

# RNN Model
rnn_model = Sequential()
rnn_model.add(Input(shape=(train_embeddings.shape[1], train_embeddings.shape[2])))
rnn_model.add(SimpleRNN(128, return_sequences=True))
rnn_model.add(GlobalMaxPooling1D())
rnn_model.add(Dense(64, activation='relu'))
rnn_model.add(Dropout(0.5))
rnn_model.add(Dense(32, activation='relu'))
rnn_model.add(Dropout(0.5))
rnn_model.add(Dense(1, activation='sigmoid'))

build_and_train_model('RNN', rnn_model)

# LSTM Model
lstm_model = Sequential()
lstm_model.add(Input(shape=(train_embeddings.shape[1], train_embeddings.shape[2])))
lstm_model.add(LSTM(128, return_sequences=True))
lstm_model.add(GlobalMaxPooling1D())
lstm_model.add(Dense(64, activation='relu'))
lstm_model.add(Dropout(0.5))
lstm_model.add(Dense(32, activation='relu'))
lstm_model.add(Dropout(0.5))
lstm_model.add(Dense(1, activation='sigmoid'))

build_and_train_model('LSTM', lstm_model)

# Bi-LSTM Model
bi_lstm_model = Sequential()
bi_lstm_model.add(Input(shape=(train_embeddings.shape[1], train_embeddings.shape[2])))
bi_lstm_model.add(Bidirectional(LSTM(128, return_sequences=True)))
bi_lstm_model.add(GlobalMaxPooling1D())
bi_lstm_model.add(Dense(64, activation='relu'))
bi_lstm_model.add(Dropout(0.5))
bi_lstm_model.add(Dense(32, activation='relu'))
bi_lstm_model.add(Dropout(0.5))
bi_lstm_model.add(Dense(1, activation='sigmoid'))

build_and_train_model('Bi-LSTM', bi_lstm_model)

X = df['preprocessed_text'].values
Y = df['label'].values

# Split the dataset into training and testing sets
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=42)

# Tokenize the text data
tokenizer = Tokenizer(num_words=10000, oov_token='<OOV>')
tokenizer.fit_on_texts(X_train)
x_train_seq = tokenizer.texts_to_sequences(X_train)
x_test_seq = tokenizer.texts_to_sequences(X_test)

# Pad the sequences
maxlen = 100
x_train_pad = pad_sequences(x_train_seq, padding='post', maxlen=maxlen)
x_test_pad = pad_sequences(x_test_seq, padding='post', maxlen=maxlen)

# Create the embedding matrix
vocab_size = len(tokenizer.word_index) + 1

# Define function to build and train model
def build_and_train_model(model_name, model):
    print(f'Training {model_name} model...')
    model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001), loss='binary_crossentropy', metrics=['accuracy'])
    history = model.fit(x_train_pad, Y_train, epochs=10, batch_size=32, validation_split=0.2)
    loss, accuracy = model.evaluate(x_test_pad, Y_test, verbose=1)
    print(f'{model_name} Test Accuracy: {accuracy}')

    # Plot the training and validation accuracy and loss
    plt.figure(figsize=(12, 4))
    plt.subplot(1, 2, 1)
    plt.plot(history.history['accuracy'], label='train_accuracy')
    plt.plot(history.history['val_accuracy'], label='val_accuracy')
    plt.xlabel('Epoch')
    plt.ylabel('Accuracy')
    plt.legend()
    plt.title(f'{model_name} Accuracy')
    plt.subplot(1, 2, 2)
    plt.plot(history.history['loss'], label='train_loss')
    plt.plot(history.history['val_loss'], label='val_loss')
    plt.xlabel('Epoch')
    plt.ylabel('Loss')
    plt.legend()
    plt.title(f'{model_name} Loss')
    plt.show()

# CNN Model
cnn_model = Sequential()
cnn_model.add(Embedding(input_dim=vocab_size, output_dim=100, input_length=maxlen))
cnn_model.add(Conv1D(filters=128, kernel_size=5, activation='relu'))
cnn_model.add(MaxPooling1D(pool_size=2))
cnn_model.add(Conv1D(filters=128, kernel_size=5, activation='relu'))
cnn_model.add(GlobalMaxPooling1D())
cnn_model.add(Dense(64, activation='relu'))
cnn_model.add(Dropout(0.5))
cnn_model.add(Dense(32, activation='relu'))
cnn_model.add(Dropout(0.5))
cnn_model.add(Dense(1, activation='sigmoid'))

build_and_train_model('CNN', cnn_model)

# RNN Model
rnn_model = Sequential()
rnn_model.add(Embedding(input_dim=vocab_size, output_dim=100, input_length=maxlen))
rnn_model.add(SimpleRNN(128, return_sequences=True))
rnn_model.add(GlobalMaxPooling1D())
rnn_model.add(Dense(64, activation='relu'))
rnn_model.add(Dropout(0.5))
rnn_model.add(Dense(32, activation='relu'))
rnn_model.add(Dropout(0.5))
rnn_model.add(Dense(1, activation='sigmoid'))

build_and_train_model('RNN', rnn_model)

# LSTM Model
lstm_model = Sequential()
lstm_model.add(Embedding(input_dim=vocab_size, output_dim=100, input_length=maxlen))
lstm_model.add(LSTM(128, return_sequences=True))
lstm_model.add(GlobalMaxPooling1D())
lstm_model.add(Dense(64, activation='relu'))
lstm_model.add(Dropout(0.5))
lstm_model.add(Dense(32, activation='relu'))
lstm_model.add(Dropout(0.5))
lstm_model.add(Dense(1, activation='sigmoid'))

build_and_train_model('LSTM', lstm_model)

# Bi-LSTM Model
bi_lstm_model = Sequential()
bi_lstm_model.add(Embedding(input_dim=vocab_size, output_dim=100, input_length=maxlen))
bi_lstm_model.add(Bidirectional(LSTM(128, return_sequences=True)))
bi_lstm_model.add(GlobalMaxPooling1D())
bi_lstm_model.add(Dense(64, activation='relu'))
bi_lstm_model.add(Dropout(0.5))
bi_lstm_model.add(Dense(32, activation='relu'))
bi_lstm_model.add(Dropout(0.5))
bi_lstm_model.add(Dense(1, activation='sigmoid'))

build_and_train_model('Bi-LSTM', bi_lstm_model)