import re import random import nltk from typing import List, Dict, Optional from sentence_transformers import SentenceTransformer import numpy as np from transformers import pipeline # Download required NLTK data try: nltk.data.find('tokenizers/punkt') except LookupError: nltk.download('punkt') try: nltk.data.find('corpora/wordnet') except LookupError: nltk.download('wordnet') try: nltk.data.find('corpora/omw-1.4') except LookupError: nltk.download('omw-1.4') from nltk.tokenize import sent_tokenize, word_tokenize from nltk.corpus import wordnet class AITextHumanizer: def __init__(self): """Initialize the text humanizer with necessary models and data""" print("Loading models...") # Load sentence transformer for semantic similarity try: self.similarity_model = SentenceTransformer('all-MiniLM-L6-v2') except Exception as e: print(f"Warning: Could not load similarity model: {e}") self.similarity_model = None # Initialize paraphrasing pipeline try: self.paraphraser = pipeline("text2text-generation", model="google/flan-t5-small", max_length=512) except Exception as e: print(f"Warning: Could not load paraphrasing model: {e}") self.paraphraser = None # Formal to casual word mappings self.formal_to_casual = { "utilize": "use", "demonstrate": "show", "facilitate": "help", "implement": "do", "consequently": "so", "therefore": "so", "nevertheless": "but", "furthermore": "also", "moreover": "also", "subsequently": "then", "accordingly": "so", "regarding": "about", "concerning": "about", "pertaining": "about", "approximately": "about", "endeavor": "try", "commence": "start", "terminate": "end", "obtain": "get", "purchase": "buy", "examine": "look at", "analyze": "study", "construct": "build", "establish": "set up", "magnitude": "size", "comprehensive": "complete", "significant": "big", "substantial": "large", "optimal": "best", "sufficient": "enough", "prior to": "before", "in order to": "to", "due to the fact that": "because", "at this point in time": "now", "in the event that": "if", } # Contractions mapping self.contractions = { "do not": "don't", "does not": "doesn't", "did not": "didn't", "will not": "won't", "would not": "wouldn't", "should not": "shouldn't", "could not": "couldn't", "cannot": "can't", "is not": "isn't", "are not": "aren't", "was not": "wasn't", "were not": "weren't", "have not": "haven't", "has not": "hasn't", "had not": "hadn't", "I am": "I'm", "you are": "you're", "he is": "he's", "she is": "she's", "it is": "it's", "we are": "we're", "they are": "they're", "I have": "I've", "you have": "you've", "we have": "we've", "they have": "they've", "I will": "I'll", "you will": "you'll", "he will": "he'll", "she will": "she'll", "it will": "it'll", "we will": "we'll", "they will": "they'll", } # Transition words that make text sound more AI-like self.ai_transition_words = [ "Furthermore,", "Moreover,", "Additionally,", "Subsequently,", "Consequently,", "Therefore,", "Nevertheless,", "However,", "In conclusion,", "To summarize,", "In summary,", "Overall,", "It is important to note that", "It should be emphasized that", "It is worth mentioning that", "It is crucial to understand that" ] # Natural alternatives self.natural_transitions = [ "Also,", "Plus,", "And,", "Then,", "So,", "But,", "Still,", "Anyway,", "By the way,", "Actually,", "Basically,", "Look,", "Listen,", "Here's the thing:", "The point is,", "What's more,", "On top of that,", "Another thing,", ] print("Humanizer initialized successfully!") def add_contractions(self, text: str) -> str: """Add contractions to make text sound more natural""" for formal, casual in self.contractions.items(): # Case insensitive replacement but preserve original case pattern = re.compile(re.escape(formal), re.IGNORECASE) text = pattern.sub(casual, text) return text def replace_formal_words(self, text: str, replacement_rate: float = 0.7) -> str: """Replace formal words with casual alternatives""" words = word_tokenize(text) for i, word in enumerate(words): word_lower = word.lower() if word_lower in self.formal_to_casual and random.random() < replacement_rate: # Preserve original case if word.isupper(): words[i] = self.formal_to_casual[word_lower].upper() elif word.istitle(): words[i] = self.formal_to_casual[word_lower].title() else: words[i] = self.formal_to_casual[word_lower] # Reconstruct text with proper spacing result = "" for i, word in enumerate(words): if i > 0 and word not in ".,!?;:": result += " " result += word return result def vary_sentence_structure(self, text: str) -> str: """Vary sentence structure to sound more natural""" sentences = sent_tokenize(text) varied_sentences = [] for sentence in sentences: # Sometimes start sentences with connecting words if random.random() < 0.3: connectors = ["Well,", "So,", "Now,", "Look,", "Actually,", "Basically,"] if not any(sentence.startswith(word) for word in connectors): sentence = random.choice(connectors) + " " + sentence.lower() # Occasionally break long sentences if len(sentence.split()) > 20 and random.random() < 0.4: words = sentence.split() mid_point = len(words) // 2 # Find a natural break point near the middle for i in range(mid_point - 3, min(mid_point + 3, len(words))): if words[i] in [',', 'and', 'but', 'or', 'so']: sentence1 = ' '.join(words[:i+1]) sentence2 = ' '.join(words[i+1:]) if sentence2: sentence2 = sentence2[0].upper() + sentence2[1:] varied_sentences.append(sentence1) sentence = sentence2 break varied_sentences.append(sentence) return ' '.join(varied_sentences) def replace_ai_transitions(self, text: str) -> str: """Replace AI-like transition words with natural alternatives""" for ai_word in self.ai_transition_words: if ai_word in text: natural_replacement = random.choice(self.natural_transitions) text = text.replace(ai_word, natural_replacement) return text def add_natural_imperfections(self, text: str, imperfection_rate: float = 0.1) -> str: """Add subtle imperfections to make text more human-like""" sentences = sent_tokenize(text) modified_sentences = [] for sentence in sentences: # Occasionally start with lowercase after punctuation (casual style) if random.random() < imperfection_rate: words = sentence.split() if len(words) > 1 and words[0].lower() in ['and', 'but', 'or', 'so']: sentence = words[0].lower() + ' ' + ' '.join(words[1:]) # Sometimes use informal punctuation if random.random() < imperfection_rate: if sentence.endswith('.'): sentence = sentence[:-1] # Remove period occasionally elif not sentence.endswith(('.', '!', '?')): if random.random() < 0.5: sentence += '.' modified_sentences.append(sentence) return ' '.join(modified_sentences) def paraphrase_segments(self, text: str, paraphrase_rate: float = 0.3) -> str: """Paraphrase some segments using the transformer model""" if not self.paraphraser: return text sentences = sent_tokenize(text) paraphrased_sentences = [] for sentence in sentences: if random.random() < paraphrase_rate and len(sentence.split()) > 5: try: # Create paraphrase prompt prompt = f"Rewrite this sentence in a more natural, conversational way: {sentence}" result = self.paraphraser(prompt, max_length=100, num_return_sequences=1) paraphrased = result[0]['generated_text'] # Clean up the result paraphrased = paraphrased.replace(prompt, '').strip() if paraphrased and len(paraphrased) > 10: paraphrased_sentences.append(paraphrased) else: paraphrased_sentences.append(sentence) except Exception as e: print(f"Paraphrasing failed: {e}") paraphrased_sentences.append(sentence) else: paraphrased_sentences.append(sentence) return ' '.join(paraphrased_sentences) def calculate_similarity(self, text1: str, text2: str) -> float: """Calculate semantic similarity between original and humanized text""" if not self.similarity_model: return 0.85 # Return reasonable default if model not available try: embeddings1 = self.similarity_model.encode([text1]) embeddings2 = self.similarity_model.encode([text2]) similarity = np.dot(embeddings1[0], embeddings2[0]) / ( np.linalg.norm(embeddings1[0]) * np.linalg.norm(embeddings2[0]) ) return float(similarity) except Exception as e: print(f"Similarity calculation failed: {e}") return 0.85 def humanize_text(self, text: str, style: str = "natural", intensity: float = 0.7) -> Dict: """ Main humanization function Args: text: Input text to humanize style: Style of humanization ('natural', 'casual', 'conversational') intensity: Intensity of humanization (0.0 to 1.0) Returns: Dictionary with humanized text and metadata """ if not text.strip(): return { "original_text": text, "humanized_text": text, "similarity_score": 1.0, "changes_made": [] } changes_made = [] humanized_text = text # Apply transformations based on intensity if intensity > 0.2: # Replace formal words before_formal = humanized_text humanized_text = self.replace_formal_words(humanized_text, intensity * 0.7) if humanized_text != before_formal: changes_made.append("Replaced formal words with casual alternatives") if intensity > 0.3: # Add contractions before_contractions = humanized_text humanized_text = self.add_contractions(humanized_text) if humanized_text != before_contractions: changes_made.append("Added contractions") if intensity > 0.4: # Replace AI-like transitions before_transitions = humanized_text humanized_text = self.replace_ai_transitions(humanized_text) if humanized_text != before_transitions: changes_made.append("Replaced AI-like transition words") if intensity > 0.5: # Vary sentence structure before_structure = humanized_text humanized_text = self.vary_sentence_structure(humanized_text) if humanized_text != before_structure: changes_made.append("Varied sentence structure") if intensity > 0.6 and style in ["casual", "conversational"]: # Add natural imperfections before_imperfections = humanized_text humanized_text = self.add_natural_imperfections(humanized_text, intensity * 0.2) if humanized_text != before_imperfections: changes_made.append("Added natural imperfections") if intensity > 0.7: # Paraphrase some segments before_paraphrase = humanized_text humanized_text = self.paraphrase_segments(humanized_text, intensity * 0.4) if humanized_text != before_paraphrase: changes_made.append("Paraphrased some segments") # Calculate similarity similarity_score = self.calculate_similarity(text, humanized_text) return { "original_text": text, "humanized_text": humanized_text, "similarity_score": similarity_score, "changes_made": changes_made, "style": style, "intensity": intensity } # Test the humanizer if __name__ == "__main__": humanizer = AITextHumanizer() # Test text test_text = """ Furthermore, it is important to note that artificial intelligence systems demonstrate significant capabilities in natural language processing tasks. Subsequently, these systems can analyze and generate text with remarkable accuracy. Nevertheless, it is crucial to understand that human oversight remains essential for optimal performance. Therefore, organizations should implement comprehensive strategies to utilize these technologies effectively while maintaining quality standards. """ print("Original Text:") print(test_text) print("\n" + "="*50 + "\n") result = humanizer.humanize_text(test_text, style="conversational", intensity=0.8) print("Humanized Text:") print(result["humanized_text"]) print(f"\nSimilarity Score: {result['similarity_score']:.3f}") print(f"Changes Made: {', '.join(result['changes_made'])}")