Update app.py

app.py

@@ -7,16 +7,53 @@ import pandas as pd
 import tensorflow as tf
 from valx import detect_profanity, detect_hate_speech
 
-def custom_pad_sequences(sequences, maxlen, padding='pre', value=0):
+# Configuration dictionary mapping game names to their max_seq_len
+MODEL_CONFIGS = {
+    "Terraria": 12, "Skyrim": 13, "Witcher": 20, "WOW": 16, "Minecraft": 17,
+    "Dark Souls": 13, "Final Fantasy": 14, "Elden Ring": 18, "Zelda": 15,
+    "Dragon Age": 16, "Fallout": 13, "Darkest Dungeon": 14, "Monster Hunter": 15,
+    "Bloodborne": 12, "Hollow Knight": 15, "Assassin's Creed": 15, "Baldur's Gate": 14,
+    "Cyberpunk": 11, "Mass Effect": 13, "God Of War": 12, "Last Of Us": 5,
+    "Factorio": 8, "The Sims": 4, "Fortnite": 9, "League Of Legends": 12,
+    "Among Us": 13, "Warframe": 13, "Call of Duty": 11, "Forza Horizon": 10,
+    "Halo": 14, "Overwatch": 9, "Subnautica": 14, "Fantasy": 16,
+    
+    # New Models in version 1.4
+    "Animal Crossing": 14, "Civilization VI": 22, "Control": 22, "Cuphead": 24,
+    "Dead Space": 18, "Diablo": 20, "Dota 2": 27, "EVE Online": 24, "GTA": 23,
+    "Hades": 20, "Metroid": 28, "Portal": 28, "Resident Evil": 21, "RimWorld": 23,
+    "Slay the Spire": 18, "Stardew Valley": 19, "Stellaris": 23, "Valheim": 20
+}
+
+# Global dictionary to store loaded models in memory
+MODEL_CACHE = {}
+
+def get_loaded_models(game_type):
     """
-    Pads sequences to the same length.
-
-    :param sequences: List of lists, where each element is a sequence.
-    :param maxlen: Maximum length of all sequences.
-    :param padding: 'pre' or 'post', pad either before or after each sequence.
-    :param value: Float, padding value.
-    :return: Numpy array with dimensions (number_of_sequences, maxlen)
+    Lazy-loads models into memory. If the model is already in the cache, 
+    it returns it instantly. Otherwise, it loads it from disk, caches it, and returns it.
     """
+    if game_type not in MODEL_CACHE:
+        file_prefix = game_type.lower().replace(" ", "_").replace("'", "")
+        
+        # Load SentencePiece Model
+        sp = spm.SentencePieceProcessor()
+        sp.load(f"models/{file_prefix}_names.model")
+
+        # Load TFLite model
+        interpreter = tf.lite.Interpreter(model_path=f"models/dungen_{file_prefix}_model.tflite")
+        interpreter.allocate_tensors()
+        
+        # Store in cache
+        MODEL_CACHE[game_type] = {
+            "sp": sp,
+            "interpreter": interpreter,
+            "vocab_size": sp.GetPieceSize()
+        }
+        
+    return MODEL_CACHE[game_type]
+
+def custom_pad_sequences(sequences, maxlen, padding='pre', value=0):
     padded_sequences = np.full((len(sequences), maxlen), value)
     for i, seq in enumerate(sequences):
         if padding == 'pre':
@@ -32,7 +69,6 @@ def custom_pad_sequences(sequences, maxlen, padding='pre', value=0):
     return padded_sequences
 
 def generate_random_name(interpreter, vocab_size, sp, max_length=10, temperature=0.5, seed_text="", max_seq_len=12):
-    # Get input and output tensors
     input_details = interpreter.get_input_details()
     output_details = interpreter.get_output_details()
     decoded_name = ''
@@ -47,40 +83,26 @@ def generate_random_name(interpreter, vocab_size, sp, max_length=10, temperature
     for _ in range(max_length - 1):
         token_list = sp.encode_as_ids(generated_name)
 
-        # Handle empty token list case
         if len(token_list) == 0:
-            continue  # Skip the current iteration if the token list is empty
+            continue  
             
-        # Pad to the correct length expected by the model
         token_list = custom_pad_sequences([token_list], maxlen=max_seq_len, padding='pre') 
-
-        # Convert token_list to FLOAT32 before setting the tensor
         token_list = token_list.astype(np.float32)
 
-        # Set the input tensor
         interpreter.set_tensor(input_details[0]['index'], token_list)
-
-        # Run inference
         interpreter.invoke()
 
-        # Get the output tensor
         predicted = interpreter.get_tensor(output_details[0]['index'])[0]
-
-        # Apply temperature to predictions
         predicted = np.log(predicted + 1e-8) / temperature
         predicted = np.exp(predicted) / np.sum(np.exp(predicted))
 
-        # Sample from the distribution
         next_index = np.random.choice(range(vocab_size), p=predicted)
         next_index = int(next_index)
         next_token = sp.id_to_piece(next_index)
 
         generated_name = sp.decode_pieces(sp.encode_as_pieces(generated_name) + [next_token])
-
-        # Decode the generated subword tokens into a string
         decoded_name = sp.decode_pieces(sp.encode_as_pieces(generated_name))
 
-        # Stop if end token is predicted (optional)
         if next_token == '' or len(decoded_name) > max_length:
             break
 
@@ -88,21 +110,17 @@ def generate_random_name(interpreter, vocab_size, sp, max_length=10, temperature
     decoded_name = decoded_name.replace("</s>", "")
     decoded_name = decoded_name.replace("<unk>", "")
     decoded_name = decoded_name.replace("<s>", "")
-    generated_name = decoded_name.strip()
-
-    generated_name = generated_name.capitalize()
+    generated_name = decoded_name.strip().capitalize()
 
-    # Split the name and check the last part
     parts = generated_name.split()
     if parts and len(parts[-1]) < 3:
         generated_name = " ".join(parts[:-1])
         
     return generated_name.strip()
 
-def generateNames(type, amount, max_length=30, temperature=0.5, seed_text=""):
+def generateNames(game_type, amount, max_length=30, temperature=0.5, seed_text=""):
     hate_speech = detect_hate_speech(seed_text)
     profanity = detect_profanity([seed_text], language='All')
-    output = ''
     
     if len(profanity) > 0:
         gr.Warning("Profanity detected in the seed text, using an empty seed text.")
@@ -114,1202 +132,65 @@ def generateNames(type, amount, max_length=30, temperature=0.5, seed_text=""):
         elif hate_speech == ['Offensive Speech']:
             gr.Warning('Offensive speech detected in the seed text, using an empty seed text.')
             seed_text = ''
-        # elif hate_speech == ['No Hate and Offensive Speech']:
-    
-    if type == "Terraria":
-        max_seq_len = 12 # For skyrim = 13, for terraria = 12
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/terraria_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_terraria_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Skyrim":
-        max_seq_len = 13 # For skyrim = 13, for terraria = 12
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/skyrim_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_skyrim_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Witcher":
-        max_seq_len = 20 # For skyrim = 13, for terraria = 12
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/witcher_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_witcher_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "WOW":
-        max_seq_len = 16 # For skyrim = 13, for terraria = 12
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/wow_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_wow_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Minecraft":
-        max_seq_len = 17 # For skyrim = 13, for terraria = 12
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/minecraft_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_minecraft_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Dark Souls":
-        max_seq_len = 13 # For skyrim = 13, for terraria = 12
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/dark_souls_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_dark_souls_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Final Fantasy":
-        max_seq_len = 14
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/final_fantasy_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_final_fantasy_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Elden Ring":
-        max_seq_len = 18
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/elden_ring_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_elden_ring_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Zelda":
-        max_seq_len = 15
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/zelda_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_zelda_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Dragon Age":
-        max_seq_len = 16 # For skyrim = 13, for terraria = 12
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/dragon_age_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
 
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_dragon_age_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Fallout":
-        max_seq_len = 13
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/fallout_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_fallout_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Darkest Dungeon":
-        max_seq_len = 14
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/darkest_dungeon_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_darkest_dungeon_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Monster Hunter":
-        max_seq_len = 15
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/monster_hunter_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_monster_hunter_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Bloodborne":
-        max_seq_len = 12
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/bloodborne_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_bloodborne_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Hollow Knight":
-        max_seq_len = 15
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/hollow_knight_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_hollow_knight_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Assassin's Creed":
-        max_seq_len = 15
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/assassins_creed_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_assassins_creed_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Baldur's Gate":
-        max_seq_len = 14
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/baldurs_gate_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_baldurs_gate_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Cyberpunk":
-        max_seq_len = 11 # For skyrim = 13, for terraria = 12
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/cyberpunk_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_cyberpunk_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Mass Effect":
-        max_seq_len = 13 # For skyrim = 13, for terraria = 12
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/mass_effect_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_mass_effect_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "God Of War":
-        max_seq_len = 12 # For skyrim = 13, for terraria = 12
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/god_of_war_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_god_of_war_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Last Of Us":
-        max_seq_len = 5 # For skyrim = 13, for terraria = 12
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/last_of_us_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_last_of_us_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Factorio":
-        max_seq_len = 8 # For skyrim = 13, for terraria = 12
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/factorio_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_factorio_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "The Sims":
-        max_seq_len = 4 # For skyrim = 13, for terraria = 12
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/the_sims_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_the_sims_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Fortnite":
-        max_seq_len = 9 # For skyrim = 13, for terraria = 12
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/fortnite_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_fortnite_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "League Of Legends":
-        max_seq_len = 12 # For skyrim = 13, for terraria = 12
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/league_of_legends_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_league_of_legends_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Among Us":
-        max_seq_len = 13 # For skyrim = 13, for terraria = 12
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/among_us_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_among_us_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Warframe":
-        max_seq_len = 13 # For skyrim = 13, for terraria = 12
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/warframe_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_warframe_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Call of Duty":
-        max_seq_len = 11 # For skyrim = 13, for terraria = 12
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/call_of_duty_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_call_of_duty_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Forza Horizon":
-        max_seq_len = 10 # For skyrim = 13, for terraria = 12
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/forza_horizon_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_forza_horizon_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Halo":
-        max_seq_len = 14 # For skyrim = 13, for terraria = 12
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/halo_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_halo_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Overwatch":
-        max_seq_len = 9 # For skyrim = 13, for terraria = 12
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/overwatch_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_overwatch_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-
-    elif type == "Subnautica":
-        max_seq_len = 14 # For skyrim = 13, for terraria = 12
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/subnautica_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_subnautica_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
-    
-    elif type == "Fantasy":
-        max_seq_len = 16 # For fantasy, 16
-        sp = spm.SentencePieceProcessor()
-        sp.load("models/fantasy_names.model")
-        amount = int(amount)
-        max_length = int(max_length)
-
-        names = []
-
-        # Define necessary variables
-        vocab_size = sp.GetPieceSize()
-
-        # Load TFLite model
-        interpreter = tf.lite.Interpreter(model_path="models/dungen_fantasy_model.tflite")
-        interpreter.allocate_tensors()
-
-        # Use the function to generate a name
-        for _ in range(amount):
-            generated_name = generate_random_name(interpreter, vocab_size, sp, seed_text=seed_text, max_length=max_length, temperature=temperature, max_seq_len=max_seq_len)
-            stripped = generated_name.strip()
-            hate_speech = detect_hate_speech(stripped)
-            profanity = detect_profanity([stripped], language='All')
-            name = ''
-    
-            if len(profanity) > 0:
-                name = "Profanity Detected"
-            else:
-                if hate_speech == ['Hate Speech']:
-                    name = 'Hate Speech Detected'
-                elif hate_speech == ['Offensive Speech']:
-                    name = 'Offensive Speech Detected'
-                elif hate_speech == ['No Hate and Offensive Speech']:
-                    name = stripped
-            names.append(name)
-        return pd.DataFrame(names, columns=['Names'])
+    if game_type not in MODEL_CONFIGS:
+        return pd.DataFrame([], columns=['Names'])
+
+    # Fetch max sequence length
+    max_seq_len = MODEL_CONFIGS[game_type]
+    
+    # Fetch cached models (loads them instantly if already cached)
+    cached_data = get_loaded_models(game_type)
+    sp = cached_data["sp"]
+    interpreter = cached_data["interpreter"]
+    vocab_size = cached_data["vocab_size"]
+
+    amount = int(amount)
+    max_length = int(max_length)
+    names = []
+
+    for _ in range(amount):
+        generated_name = generate_random_name(
+            interpreter, vocab_size, sp, 
+            seed_text=seed_text, max_length=max_length, 
+            temperature=temperature, max_seq_len=max_seq_len
+        )
+        stripped = generated_name.strip()
+        item_hate_speech = detect_hate_speech(stripped)
+        item_profanity = detect_profanity([stripped], language='All')
+        name = ''
+
+        if len(item_profanity) > 0:
+            name = "Profanity Detected"
+        else:
+            if item_hate_speech == ['Hate Speech']:
+                name = 'Hate Speech Detected'
+            elif item_hate_speech == ['Offensive Speech']:
+                name = 'Offensive Speech Detected'
+            elif item_hate_speech == ['No Hate and Offensive Speech']:
+                name = stripped
+        
+        names.append(name)
+        
+    return pd.DataFrame(names, columns=['Names'])
 
 demo = gr.Interface(
     fn=generateNames,
-    inputs=[gr.Radio(choices=["Terraria", "Skyrim", "Witcher", "WOW", "Minecraft", "Dark Souls", "Final Fantasy", "Elden Ring", "Zelda", "Dragon Age", "Fallout", "Darkest Dungeon", "Monster Hunter", "Bloodborne", "Hollow Knight", "Assassin's Creed", "Baldur's Gate", "Cyberpunk", "Mass Effect", "God Of War", "Last Of Us", "Factorio", "The Sims", "Fortnite", "League Of Legends", "Among Us", "Warframe", "Call of Duty", "Forza Horizon", "Halo", "Overwatch", "Subnautica", "Fantasy"], label="Choose a model for your request", value="Terraria"), gr.Slider(1,100, step=1, label='Amount of Names', info='How many names to generate, must be greater than 0'), gr.Slider(10, 60, value=30, step=1, label='Max Length', info='Max length of the generated word'), gr.Slider(0.1, 1, value=0.5, label='Temperature', info='Controls randomness of generation, higher values = more creative, lower values = more probalistic'), gr.Textbox('', label='Seed text (optional)', info='The starting text to begin with', max_lines=1, )],
-    outputs=[gr.Dataframe(row_count = (2, "dynamic"), col_count=(1, "fixed"), label="Generated Names", headers=["Names"])],
+    inputs=[
+        gr.Radio(
+            choices=list(MODEL_CONFIGS.keys()), 
+            label="Choose a model for your request", 
+            value="Terraria"
+        ), 
+        gr.Slider(1, 100, step=1, label='Amount of Names', info='How many names to generate, must be greater than 0'), 
+        gr.Slider(10, 60, value=30, step=1, label='Max Length', info='Max length of the generated word'), 
+        gr.Slider(0.1, 1, value=0.5, label='Temperature', info='Controls randomness of generation, higher values = more creative, lower values = more probalistic'), 
+        gr.Textbox('', label='Seed text (optional)', info='The starting text to begin with', max_lines=1)
+    ],
+    outputs=[gr.Dataframe(row_count=(2, "dynamic"), col_count=(1, "fixed"), label="Generated Names", headers=["Names"])],
     title='Dungen - Name Generator',
     description='A fun game-inspired name generator. For an example of how to create, and train your model, like this one, head over to: https://github.com/Infinitode/OPEN-ARC/tree/main/Project-5-TWNG. There you will find our base model, the dataset we used, and implementation code in the form of a Jupyter Notebook (exported from Kaggle).'
 )
 
-demo.launch()
+if __name__ == "__main__":
+    demo.launch()