app.py

import streamlit as st
#subtitle 
st.markdown("version: 2.0")
#title 
st.title("Smart Detection System of AI-Generated Text Models")

#subtitle 
st.markdown("This is a POC for Smart Detection System of AI Generated Text Models project (:blue[MSc Data Analytics]), it is a pre-trained model that detect the probablities of using any of the known LLM (chatgpt3, chatgpt4, GoogleBard, HuggingfaceChat)")

import pickle
import pandas as pd
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.linear_model import RidgeClassifier
import os
import requests

import numpy as np
############



# Check if the file exists
if not os.path.isfile('ridge_100%_BOW_ngram_full_text.pkl'):

    url = 'https://jaifar.net/ridge_100%_BOW_ngram_full_text.pkl'
    headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3',
    }

    response = requests.get(url, headers=headers)


    with open('ridge_100%_BOW_ngram_full_text.pkl', 'wb') as file:
        file.write(response.content)


# At this point, the pickle file should exist, either it was already there, or it has been downloaded and extracted.
with open('ridge_100%_BOW_ngram_full_text.pkl', 'rb') as file:
    clf_loaded = pickle.load(file)

input_paragraph = st.text_area("Input your text here")
words_counts = word_tokenize(input_paragraph)
final_words = len(words_counts)
st.write('Words counts: ', final_words)

# Creates a button named 'Press me'
press_me_button = st.button("Which Model Used?")

df = pd.DataFrame([input_paragraph], columns=["paragraph"])

# Extracting features
def extract_features(text):
    vectorizer = CountVectorizer(ngram_range=(1, 2))

    # Convert the paragraphs into a matrix of token counts
    X_vect = vectorizer.fit_transform(text)

    # Get the feature names
    feature_names = vectorizer.get_feature_names_out()

    # Convert the matrix to a DataFrame
    X_df = pd.DataFrame(X_vect.toarray(), columns=feature_names)


    return pd.Series(X_df)


if press_me_button:
    input_features = df['paragraph'].apply(extract_features)
    predicted_llm = clf_loaded.predict(input_features)
    st.write(f"Predicted LLM: {predicted_llm[0]}")

    # predicted_proba = clf_loaded.predict_proba(input_features)
    # probabilities = predicted_proba[0]
    # labels = clf_loaded.classes_

    # # Create a mapping from old labels to new labels
    # label_mapping = {1: 'gpt3', 2: 'gpt4', 3: 'googlebard', 4: 'huggingface'}

    # # Apply the mapping to the labels
    # new_labels = [label_mapping[label] for label in labels]

    # # Create a dictionary that maps new labels to probabilities
    # prob_dict = {k: v for k, v in zip(new_labels, probabilities)}

    # # Convert probabilities to percentages and sort the dictionary in descending order
    # prob_dict = {k: f'{v*100:.2f}%' for k, v in sorted(prob_dict.items(), key=lambda item: item[1], reverse=True)}

    # # Print the dictionary
    # #st.write(prob_dict)

    # # Create a progress bar and a bar chart for each LLM
    # for llm, prob in prob_dict.items():
    #     st.write(llm + ': ' + prob)
    #     st.progress(float(prob.strip('%'))/100)



#####################################################################

# import streamlit as st
# #subtitle 
# st.markdown("version: 1.2")
# #title 
# st.title("Smart Detection System of AI-Generated Text Models")

# #subtitle 
# st.markdown("This is a POC for Smart Detection System of AI Generated Text Models project (:blue[MSc Data Analytics]), it is a pre-trained model that detect the probablities of using any of the known LLM (chatgpt3, chatgpt4, GoogleBard, HuggingfaceChat)")

# import os
# import requests
# # import pickle
# import pandas as pd
# import nltk
# import spacy
# from nltk.corpus import stopwords
# from nltk.tokenize import word_tokenize, sent_tokenize
# import numpy as np
# ############
# from nltk.stem import WordNetLemmatizer
# from nltk import ne_chunk, pos_tag, word_tokenize
# from nltk.tree import Tree
# from joblib import dump, load
# nltk.download('wordnet')
# nltk.download('maxent_ne_chunker')
# nltk.download('words')

# #######
# nltk.download('punkt')
# nltk.download('stopwords')
# nltk.download('averaged_perceptron_tagger')

# # Check if the file exists
# if not os.path.isfile('RandomForestClassifier.joblib'):

#     url = 'https://jaifar.net/RandomForestClassifier.joblib'
#     headers = {
#     'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3',
#     }

#     response = requests.get(url, headers=headers)


#     with open('RandomForestClassifier.joblib', 'wb') as file:
#         file.write(response.content)


# # Load the model from the file
# clf_loaded = load('RandomForestClassifier.joblib')

# # # At this point, the pickle file should exist, either it was already there, or it has been downloaded and extracted.
# # with open('RandomForestClassifier.pkl', 'rb') as file:
# #     clf_loaded = pickle.load(file)

# input_paragraph = st.text_area("Input your text here")
# words_counts = word_tokenize(input_paragraph)
# final_words = len(words_counts)
# st.write('Words counts: ', final_words)



# # df = pd.DataFrame(columns=["paragraph"])
# # df = df.append({"paragraph": input_paragraph}, ignore_index=True)

# df = pd.DataFrame([input_paragraph], columns=["paragraph"])



# # Variable to control number of words to retrieve
# num_words = 500

# # Retrieving only the first num_words words of the paragraph
# input_paragraph = ' '.join(word_tokenize(input_paragraph)[:num_words])

# # Extracting features
# def extract_features(text):
#     words = word_tokenize(text)
#     sentences = sent_tokenize(text)

#     avg_word_length = sum(len(word) for word in words if word.isalpha()) / len(words)
#     avg_sent_length = sum(len(sent) for sent in sentences) / len(sentences)
#     punctuation_count = len([char for char in text if char in '.,;:?!'])
#     stopword_count = len([word for word in words if word in stopwords.words('english')])

#     lemmatizer = WordNetLemmatizer()
#     lemma_count = len(set(lemmatizer.lemmatize(word) for word in words))

#     named_entity_count = len([chunk for chunk in ne_chunk(pos_tag(words)) if isinstance(chunk, Tree)])

#     tagged_words = nltk.pos_tag(words)
#     pos_counts = nltk.FreqDist(tag for (word, tag) in tagged_words)
#     pos_features = {
#         'pos_IN': pos_counts['IN'],
#         'pos_DT': pos_counts['DT'],
#         'pos_NN': pos_counts['NN'],
#         'pos_,': pos_counts[','],
#         'pos_VBZ': pos_counts['VBZ'],
#         'pos_WDT': pos_counts['WDT'],
#         'pos_TO': pos_counts['TO'],
#         'pos_VB': pos_counts['VB'],
#         'pos_VBG': pos_counts['VBG'],
#         'pos_.': pos_counts['.'],
#         'pos_JJ': pos_counts['JJ'],
#         'pos_NNS': pos_counts['NNS'],
#         'pos_RB': pos_counts['RB'],
#         'pos_CC': pos_counts['CC'],
#         'pos_VBN': pos_counts['VBN'],
#     }

#     features = {
#         'avg_word_length': avg_word_length,
#         'avg_sent_length': avg_sent_length,
#         'punctuation_count': punctuation_count,
#         'stopword_count': stopword_count,
#         'lemma_count': lemma_count,
#         'named_entity_count': named_entity_count,
#     }
#     features.update(pos_features)

#     return pd.Series(features)


# # Creates a button named 'Press me'
# press_me_button = st.button("Which Model Used?")

# if press_me_button:
#     input_features = df['paragraph'].apply(extract_features)
#     predicted_llm = clf_loaded.predict(input_features)
#     #st.write(f"Predicted LLM: {predicted_llm[0]}")

#     predicted_proba = clf_loaded.predict_proba(input_features)
#     probabilities = predicted_proba[0]
#     labels = clf_loaded.classes_

#     # Create a mapping from old labels to new labels
#     label_mapping = {1: 'gpt3', 2: 'gpt4', 3: 'googlebard', 4: 'huggingface'}

#     # Apply the mapping to the labels
#     new_labels = [label_mapping[label] for label in labels]

#     # Create a dictionary that maps new labels to probabilities
#     prob_dict = {k: v for k, v in zip(new_labels, probabilities)}

#     # Convert probabilities to percentages and sort the dictionary in descending order
#     prob_dict = {k: f'{v*100:.2f}%' for k, v in sorted(prob_dict.items(), key=lambda item: item[1], reverse=True)}

#     # Print the dictionary
#     #st.write(prob_dict)

#     # Create a progress bar and a bar chart for each LLM
#     for llm, prob in prob_dict.items():
#         st.write(llm + ': ' + prob)
#         st.progress(float(prob.strip('%'))/100)

############################################################


# import streamlit as st
# import os
# import requests
# import pickle
# import pandas as pd
# import nltk
# import spacy
# from nltk.corpus import stopwords
# from nltk.tokenize import word_tokenize, sent_tokenize
# import numpy as np
# ############
# from nltk.stem import WordNetLemmatizer
# from nltk import ne_chunk, pos_tag, word_tokenize
# from nltk.tree import Tree
# from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
# nltk.download('wordnet')
# nltk.download('maxent_ne_chunker')
# nltk.download('words')

# #######
# nltk.download('punkt')
# nltk.download('stopwords')
# nltk.download('averaged_perceptron_tagger')

# #version
# st.markdown("v1.9")


# # URL of the text file
# url = 'https://jaifar.net/text.txt'

# headers = {
# 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3',
# }

# response = requests.get(url, headers=headers)

# # Check if the request was successful
# if response.status_code == 200:
#     # Read the content of the file
#     content = response.text

#     # Print the content of the file
#     # print(content)
# else:
#     # Handle the case when the request fails
#     print('Failed to download the file.')



# #title 
# st.title("Smart Detection System of AI-Generated Text Models")

# #subtitle 
# st.markdown("This is a POC for Smart Detection System of AI Generated Text Models project (:blue[MSc Data Analytics]), it is a pre-trained model that detect the probablities of using any of the known LLM (chatgpt3, chatgpt4, GoogleBard, HuggingfaceChat)")

# #input text 
# input_paragraph = st.text_area("Input your text here")
# words_counts = word_tokenize(input_paragraph)
# final_words = len(words_counts)
# st.write('Words counts: ', final_words)

# # Define your options
# options = ["AI vs AI - RandomForest - 88 Samples", "AI vs AI - Ridge - 2000 Samples", "AI vs Human"]

# # Create a dropdown menu with "Option 2" as the default
# # selected_option = st.selectbox('Select an Option', options, index=1)
# selected_option = st.selectbox('Select an Option', options)





# # Check if the file exists
# if not os.path.isfile('AI_vs_AI_Ridge_2000_Samples.pkl'):
#     # Download the zip file if it doesn't exist
#     url = 'https://jaifar.net/AI_vs_AI_Ridge_2000_Samples.pkl'
#     headers = {
#     'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3',
#     }

#     response = requests.get(url, headers=headers)

#     # Save the file
#     with open('AI_vs_AI_Ridge_2000_Samples.pkl', 'wb') as file2:
#         file2.write(response.content)



# # df = pd.DataFrame(columns=["paragraph"])
# # df = df.append({"paragraph": input_paragraph}, ignore_index=True)

# df = pd.DataFrame([input_paragraph], columns=["paragraph"])



# # Variable to control number of words to retrieve
# num_words = 500

# # Retrieving only the first num_words words of the paragraph
# input_paragraph = ' '.join(word_tokenize(input_paragraph)[:num_words])


# # Extracting features
# def extract_features_AI_vs_AI_RandomForest_88_Samples(text):
#     words = word_tokenize(text)
#     sentences = sent_tokenize(text)

#     avg_word_length = sum(len(word) for word in words if word.isalpha()) / len(words)
#     avg_sent_length = sum(len(sent) for sent in sentences) / len(sentences)
#     punctuation_count = len([char for char in text if char in '.,;:?!'])
#     stopword_count = len([word for word in words if word in stopwords.words('english')])

#     lemmatizer = WordNetLemmatizer()
#     lemma_count = len(set(lemmatizer.lemmatize(word) for word in words))

#     named_entity_count = len([chunk for chunk in ne_chunk(pos_tag(words)) if isinstance(chunk, Tree)])

#     tagged_words = nltk.pos_tag(words)
#     pos_counts = nltk.FreqDist(tag for (word, tag) in tagged_words)
#     pos_features = {
#         'pos_IN': pos_counts['IN'],
#         'pos_DT': pos_counts['DT'],
#         'pos_NN': pos_counts['NN'],
#         'pos_,': pos_counts[','],
#         'pos_VBZ': pos_counts['VBZ'],
#         'pos_WDT': pos_counts['WDT'],
#         'pos_TO': pos_counts['TO'],
#         'pos_VB': pos_counts['VB'],
#         'pos_VBG': pos_counts['VBG'],
#         'pos_.': pos_counts['.'],
#         'pos_JJ': pos_counts['JJ'],
#         'pos_NNS': pos_counts['NNS'],
#         'pos_RB': pos_counts['RB'],
#         'pos_CC': pos_counts['CC'],
#         'pos_VBN': pos_counts['VBN'],
#     }

#     features = {
#         'avg_word_length': avg_word_length,
#         'avg_sent_length': avg_sent_length,
#         'punctuation_count': punctuation_count,
#         'stopword_count': stopword_count,
#         'lemma_count': lemma_count,
#         'named_entity_count': named_entity_count,
#     }
#     features.update(pos_features)

#     return pd.Series(features)



# # Extracting features for AI_vs_AI_Ridge_2000_Samples
# def extract_features_AI_vs_AI_Ridge_2000_Samples(text):
    
#     words = word_tokenize(text)
#     sentences = sent_tokenize(text)

#     avg_word_length = sum(len(word) for word in words if word.isalpha()) / len(words)
#     avg_sent_length = sum(len(sent) for sent in sentences) / len(sentences)
#     punctuation_count = len([char for char in text if char in '.,;:?!'])
#     stopword_count = len([word for word in words if word in stopwords.words('english')])

#     lemmatizer = WordNetLemmatizer()
#     lemma_count = len(set(lemmatizer.lemmatize(word) for word in words))

#     named_entity_count = len([chunk for chunk in ne_chunk(pos_tag(words)) if isinstance(chunk, Tree)])

#     tagged_words = nltk.pos_tag(words)
#     pos_counts = nltk.FreqDist(tag for (word, tag) in tagged_words)
#     pos_features = {
#         'pos_IN': pos_counts['IN'],
#         'pos_DT': pos_counts['DT'],
#         'pos_NN': pos_counts['NN'],
#         'pos_,': pos_counts[','],
#         'pos_VBZ': pos_counts['VBZ'],
#         'pos_WDT': pos_counts['WDT'],
#         'pos_TO': pos_counts['TO'],
#         'pos_VB': pos_counts['VB'],
#         'pos_PRP': pos_counts['PRP'],
#         'pos_VBP': pos_counts['VBP'],
#         'pos_VBG': pos_counts['VBG'],
#         'pos_.': pos_counts['.'],
#         'pos_JJ': pos_counts['JJ'],
#         'pos_NNS': pos_counts['NNS'],
#         'pos_RB': pos_counts['RB'],
#         'pos_PRP$': pos_counts['PRP$'],
#         'pos_CC': pos_counts['CC'],
#         'pos_MD': pos_counts['MD'],
#         'pos_VBN': pos_counts['VBN'],
#         'pos_NNP': pos_counts['NNP'],
#     }

#     features = {
#         'avg_word_length': avg_word_length,
#         'avg_sent_length': avg_sent_length,
#         'punctuation_count': punctuation_count,
#         'stopword_count': stopword_count,
#         'lemma_count': lemma_count,
#         'named_entity_count': named_entity_count,
#     }
#     # features.update(pos_features)
#     features = pd.concat([features, pd.DataFrame(pos_features, index=[0])], axis=1)

#     return pd.Series(features)

# # Function from Code(2)
# def add_vectorized_features(df):
#     vectorizer = CountVectorizer()
#     tfidf_vectorizer = TfidfVectorizer()
#     X_bow = vectorizer.fit_transform(df['paragraph'])
#     X_tfidf = tfidf_vectorizer.fit_transform(df['paragraph'])
#     df_bow = pd.DataFrame(X_bow.toarray(), columns=vectorizer.get_feature_names_out())
#     df_tfidf = pd.DataFrame(X_tfidf.toarray(), columns=tfidf_vectorizer.get_feature_names_out())
#     df = pd.concat([df, df_bow, df_tfidf], axis=1)
#     return df


# # Function define AI_vs_AI_RandomForest_88_Samples
# def AI_vs_AI_RandomForest_88_Samples(df):
    



#     input_features = df['paragraph'].apply(extract_features_AI_vs_AI_RandomForest_88_Samples)
#     # try:
#     #     predicted_llm = clf_loaded.predict(input_features)
#     #     st.write(f"Predicted LLM: {predicted_llm[0]}")
#     #     predicted_proba = clf_loaded.predict_proba(input_features)
#     # except Exception as e:
#     #     st.write(f"An error occurred: {str(e)}")

#     # labels = clf_loaded.classes_

#     # # Create a mapping from old labels to new labels
#     # label_mapping = {1: 'gpt3', 2: 'gpt4', 3: 'googlebard', 4: 'huggingface'}

#     # # Apply the mapping to the labels
#     # new_labels = [label_mapping[label] for label in labels]

#     # # Create a dictionary that maps new labels to probabilities
#     # prob_dict = {k: v for k, v in zip(new_labels, probabilities)}

#     # # Convert probabilities to percentages and sort the dictionary in descending order
#     # prob_dict = {k: f'{v*100:.2f}%' for k, v in sorted(prob_dict.items(), key=lambda item: item[1], reverse=True)}

#     # # Print the dictionary
#     # #st.write(prob_dict)

#     # # Create a progress bar and a bar chart for each LLM
#     # for llm, prob in prob_dict.items():
#     #     st.write(llm + ': ' + prob)
#     #     st.progress(float(prob.strip('%'))/100)
#     return 


# def AI_vs_AI_Ridge_2000_Samples(df):

#     # At this point, the pickle file should exist, either it was already there, or it has been downloaded and extracted.
#     with open('AI_vs_AI_Ridge_2000_Samples.pkl', 'rb') as file2:
#         clf_loaded = pickle.load(file2)

    
#     input_features = df['paragraph'].apply(extract_features_AI_vs_AI_Ridge_2000_Samples)

#     # Here, input_features is a DataFrame, not a Series
#     input_features = pd.concat(input_features.values, ignore_index=True)

#     # Add new vectorized features
#     df = add_vectorized_features(df)

#     # Concatenate input_features and df along columns
#     final_features = pd.concat([input_features, df], axis=1)

#     predicted_llm = clf_loaded.predict(final_features)
#     st.write(f"Predicted LLM: {predicted_llm[0]}")

#     return



# # Check if the file exists
# if not os.path.isfile('RandomForestClassifier.pkl'):
# # Download the zip file if it doesn't exist
#     url = 'https://jaifar.net/RandomForestClassifier.pkl'
#     headers = {
#         'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3',
#     }

#     response = requests.get(url, headers=headers)

#     # Save the file
#     try:
#         with open('RandomForestClassifier.pkl', 'wb') as file:
#             file.write(response.content)
#     except Exception as e:
#         st.write(f"An error occurred while writing RandomForestClassifier.pkl: {str(e)}") 

# try:
#     with open('RandomForestClassifier.pkl', 'rb') as file:
#         clf_loaded = pickle.load(file)
# except Exception as e:
#     st.write(f"An error occurred while loading RandomForestClassifier.pkl: {str(e)}")

# # Creates a button
# press_me_button = st.button("Which Model Used?")

# if press_me_button:

#     input_features = df['paragraph'].apply(extract_features_AI_vs_AI_RandomForest_88_Samples)
    
#     try:
#         predicted_llm = clf_loaded.predict(input_features)
#         st.write(f"Predicted LLM: {predicted_llm[0]}")
#         predicted_proba = clf_loaded.predict_proba(input_features)
#     except Exception as e:
#         st.write(f"An error occurred: {str(e)}")

#     # # Use the selected option to control the flow of your application
#     # if selected_option == "AI vs AI - RandomForest - 88 Samples":
#     #     AI_vs_AI_RandomForest_88_Samples(df)

#     # elif selected_option == "AI vs AI - Ridge - 2000 Samples":
#     #     AI_vs_AI_Ridge_2000_Samples(df)

#     # elif selected_option == "AI vs Human":
#     #     st.write("You selected AI vs Human!")