Update app.py

app.py

@@ -10,40 +10,147 @@ api_key = os.getenv("OPENAI_API_KEY")
 client = OpenAI(api_key = api_key)
 
 # finetuned model instance
-finetuned_model = "ft:gpt-3.5-turbo-0125:personal::9rLkyNae"
+finetuned_model = "ft:gpt-3.5-turbo-0125:personal::9rMWxuyj"
 
-# function to humanize the text
+
+
+
+
+
+
+# text processing functions
+def random_capitalize(word):
+    if word.isalpha() and random.random() < 0.1:
+        return word.capitalize()
+    return word
+
+def random_remove_punctuation(text):
+    if random.random() < 0.2:
+        text = list(text)
+        indices = [i for i, c in enumerate(text) if c in string.punctuation]
+        if indices:
+            remove_indices = random.sample(indices, min(3, len(indices)))
+            for idx in sorted(remove_indices, reverse=True):
+                text.pop(idx)
+        return ''.join(text)
+    return text
+
+def random_double_period(text):
+    if random.random() < 0.2:
+        text = text.replace('.', '..', 3)
+    return text
+
+def random_double_space(text):
+    if random.random() < 0.2:
+        words = text.split()
+        for _ in range(min(3, len(words) - 1)):
+            idx = random.randint(0, len(words) - 2)
+            words[idx] += '  '
+        return ' '.join(words)
+    return text
+
+def random_replace_comma_space(text, period_replace_percentage=0.33):
+
+  # Count occurrences
+  comma_occurrences = text.count(", ")
+  period_occurrences = text.count(". ")
+
+  # Replacements
+  replace_count_comma = max(1, comma_occurrences // 3)
+  replace_count_period = max(1, period_occurrences // 3)
+
+  # Find indices
+  comma_indices = [i for i in range(len(text)) if text.startswith(", ", i)]
+  period_indices = [i for i in range(len(text)) if text.startswith(". ", i)]
+
+  # Sample indices
+  replace_indices_comma = random.sample(comma_indices, min(replace_count_comma, len(comma_indices)))
+  replace_indices_period = random.sample(period_indices, min(replace_count_period, len(period_indices)))
+
+  # Apply replacements
+  for idx in sorted(replace_indices_comma + replace_indices_period, reverse=True):
+    if text.startswith(", ", idx):
+      text = text[:idx] + " ," + text[idx + 2:]
+    if text.startswith(". ", idx):
+      text = text[:idx] + " ." + text[idx + 2:]
+
+  return text
+
+def transform_paragraph(paragraph):
+    words = paragraph.split()
+    if len(words) > 12:
+        words = [random_capitalize(word) for word in words]
+
+        transformed_paragraph = ' '.join(words)
+        transformed_paragraph = random_remove_punctuation(transformed_paragraph)
+        transformed_paragraph = random_double_period(transformed_paragraph)
+        transformed_paragraph = random_double_space(transformed_paragraph)
+        transformed_paragraph = random_replace_comma_space(transformed_paragraph)
+    else:
+        transformed_paragraph = paragraph
+
+    transformed_paragraph = transformed_paragraph.replace("#", "*")
+    transformed_paragraph = transformed_paragraph.replace("*", "")
+    # transformed_paragraph = transformed_paragraph.replace(", ", " ,")
+
+    return transformed_paragraph
+
+def transform_text(text):
+    paragraphs = text.split('\n')
+    transformed_paragraphs = [transform_paragraph(paragraph) for paragraph in paragraphs]
+    return '\n'.join(transformed_paragraphs)
+
+# function to humanize text
 def humanize_text(AI_text):
-  """Humanizes the provided AI text using the fine-tuned model."""
-  response = completion = client.chat.completions.create(
-  model=finetuned_model,
-  messages=[
-    {"role": "system", "content": """
-    You are a text humanizer.
-    You humanize AI generated text.
-    The text must appear like humanly written.
-    THE OUTPUT MUST BE HIGHLY READIBLE AND GRAMMATICALLY CORRECT.
-    NO SPECIAL CHARACTERS AND WORDS ARE ALLOWED.
-    DO HUMANIZE PARGRAPH BY PARAGRAPH - DO NOT ADD ANY EXTRA KNOWLEDGE ON YOUR OWN JUST FOCUS ON WHAT IS THERE IN THE PARAGRAPH AND HUMANIZE IT IN THE BEST POSSIBLE AND READIBLE GRAMMAR AND SENTENCES.
-    THE HEADINGS AND THE BULLETS IN THE INPUT SHOULD REMAIN IN PLACE"""},
-    {"role": "user", "content": f"THE LANGUAGE OF THE INPUT AND THE OUTPUT MUST BE SAME. THE SENTENCES SHOULD NOT BE SHORT LENGTH"},
-    {"role": "user", "content": f"Humanize the text. KEEP ALL THE INSTRUCTIONS GIVEN IN MIND!! AND DONT HALLUCINATE!! \nTEXT: {AI_text}"}
-  ]
-  )
-
-
-  return response.choices[0].message.content.strip()
+    """Humanizes the provided AI text using the fine-tuned model."""
+    response = client.chat.completions.create(
+        model=finetuned_model,
+        temperature = 0.89,
+        messages=[
+            {"role": "system", "content": """
+            You are a text humanizer.
+            You humanize AI generated text.
+            The text must appear like humanly written.
+            THE INPUT AND THE OUTPUT HEADINGS MUST BE SAME. NO HEADING SHOULD BE MISSED.
+            NAMES LIKE NOVEL NAME SHOULD REMAIN INTACT WITHOUT ANY CHANGE.
+            THE INPUT AND THE OUTPUT TEXT SHOULD HAVE THE SAME FORMAT.
+            THE INPUT AND THE OUTPUT SHOULD HAVE SAME WORD COUNT.
+            THE OUTPUT SENTENCES MUST NOT BE SIMPLE. THEY SHOULD BE COMPOUND, COMPLEX, OR COMPOUND COMPLEX. 
+            THE HEADINGS AND THE BULLETS IN THE INPUT SHOULD REMAIN IN PLACE"""},
+            {"role": "system", "content": "YOU ARE TEXT HUMANIZER BUT YOU DO NOT REDUCE THE LENGTH OF THE SENTENCES. YOUR OUTPUT SENTENCES ARE OF EXACTLY THE SAME LENGTH AS THE INPUT"},
+            {"role": "user", "content": f"THE LANGUAGE OF THE INPUT AND THE OUTPUT MUST BE SAME. THE SENTENCES SHOULD NOT BE SHORT LENGTH - THEY SHOULD BE SAME AS IN THE INPUT. ALSO THE PARAGRAPHS SHOULD NOT BE SHORT EITHER - PARAGRAPHS MUST HAVE THE SAME LENGTH"},
+            {"role": "user", "content": f"DESPITE INSTRUCTIONS, YOU OFTEN BREAK THE SENTENCES INTO SMALLER MEANINGLESS SENTENCES, WHICH IS NOT ALLOWED. THE LENGTH OF THE SENTENCES IN OUTPUT SHOULD BE SAME AS THE INPUT!!!!"},
+            {"role": "assistant", "content": "It is an industry-specific term. Therefore its understanding needs context. Here this context is used to explain SCAR. The explanation will proceed as follows."},
+            {"role": "user", "content": "YOU AGAIN USED VERY SHORT AND MEANINGLESS SENTENCES WHICH ARE PROHIBITED!!!!!. The correct output should be: SCAR is regulatory measure. It juxtaposes an insurance company's available capital to needed capital. This for potential losses those derived from various risks. This capital is what's left when liabilities are subtracted from assets. "},
+            {"role": "assistant", "content": "Solvency simulation. A fundamental dimension in risk control for insurance corporations."},
+            {"role": "user", "content": "You again constructed short sentences despite guidance. The ideal format should be: Solvency modeling it's essential for insurance companies' risk control"},
+            {"role": "user", "content": "Use as many conjunctions and punctuations to make the sentence long. COMPOUND, COMPLEX, OR COMPOUND COMPLEX sentences are required"},
+            {"role": "user", "content": f"Humanize the text. Keep the output format i.e. the bullets and the headings as it is and don't use the list of words that are not permissible. \nTEXT: {AI_text}"}
+        ]
+    )
+
+    return response.choices[0].message.content.strip()
+
+
+
+def main_function(AI_text)
+    humanized_text = humanize_text(AI_text)
+    humanized_text= transform_text(humanized_text)
+    return humanized_text
+
+
 
 
 # Gradio interface definition
 interface = gr.Interface(
-  fn=humanize_text,
+  fn=main_function,
   inputs="textbox",
   outputs="textbox",
   title="AI Text Humanizer",
   description="Enter AI-generated text and get a human-written version.",
 )
 
+
 # Launch the Gradio app
 interface.launch(debug = True)