PraisonAI 2.0.63__tar.gz → 2.0.64__tar.gz

{praisonai-2.0.63 → praisonai-2.0.64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: PraisonAI
-Version: 2.0.63
+Version: 2.0.64
 Summary: PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration.
 Author: Mervin Praison
 Requires-Python: >=3.10,<3.13
@@ -208,6 +208,8 @@ const agent = new Agent({ instructions: 'You are a helpful AI assistant' });
 agent.start('Write a movie script about a robot in Mars');
 ```
 
+![PraisonAI CLI Demo](docs/demo/praisonai-cli-demo.gif)
+
 ## AI Agents Flow
 
 ```mermaid

{praisonai-2.0.63 → praisonai-2.0.64}/README.md

@@ -118,6 +118,8 @@ const agent = new Agent({ instructions: 'You are a helpful AI assistant' });
 agent.start('Write a movie script about a robot in Mars');
 ```
 
+![PraisonAI CLI Demo](docs/demo/praisonai-cli-demo.gif)
+
 ## AI Agents Flow
 
 ```mermaid

{praisonai-2.0.63 → praisonai-2.0.64}/praisonai/cli.py

@@ -25,7 +25,7 @@ CALL_MODULE_AVAILABLE = False
 CREWAI_AVAILABLE = False
 AUTOGEN_AVAILABLE = False
 PRAISONAI_AVAILABLE = False
-
+TRAIN_AVAILABLE = False
 try:
     # Create necessary directories and set CHAINLIT_APP_ROOT
     if "CHAINLIT_APP_ROOT" not in os.environ:
@@ -72,6 +72,12 @@ try:
 except ImportError:
     pass
 
+try:
+    import accelerate
+    TRAIN_AVAILABLE = True
+except ImportError:
+    pass
+
 logging.basicConfig(level=os.environ.get('LOGLEVEL', 'INFO'), format='%(asctime)s - %(levelname)s - %(message)s')
 logging.getLogger('alembic').setLevel(logging.ERROR)
 logging.getLogger('gradio').setLevel(logging.ERROR)
@@ -393,9 +399,13 @@ class PraisonAI:
                 sys.exit(0)
 
             elif args.command == 'train':
-                print("[red]ERROR: Train feature is not installed. Install with:[/red]")
-                print("\npip install \"praisonai[train]\"\n")
-                sys.exit(1)
+                if not TRAIN_AVAILABLE:
+                    print("[red]ERROR: Train feature is not installed. Install with:[/red]")
+                    print("\npip install \"praisonai[train]\"\n")
+                    sys.exit(1)
+                package_root = os.path.dirname(os.path.abspath(__file__))
+                config_yaml_destination = os.path.join(os.getcwd(), 'config.yaml')
+                
 
             elif args.command == 'ui':
                 if not CHAINLIT_AVAILABLE:

{praisonai-2.0.63 → praisonai-2.0.64}/praisonai/deploy.py

@@ -56,7 +56,7 @@ class CloudDeployer:
             file.write("FROM python:3.11-slim\n")
             file.write("WORKDIR /app\n")
             file.write("COPY . .\n")
-            file.write("RUN pip install flask praisonai==2.0.63 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==2.0.64 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

{praisonai-2.0.63 → praisonai-2.0.64}/praisonai/setup/setup_conda_env.sh

@@ -11,6 +11,20 @@ if [[ "$OSTYPE" == "darwin"* ]]; then
 elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
     # Linux
     MINICONDA_URL="https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh"
+    
+    # Check and install libcurl development package if not present
+    if command -v dpkg &> /dev/null; then
+        if ! dpkg -s libcurl4-openssl-dev &> /dev/null; then
+            echo "libcurl4-openssl-dev is not installed. Installing..."
+            sudo apt-get update
+            sudo apt-get install -y libcurl4-openssl-dev
+        else
+            echo "libcurl4-openssl-dev is already installed."
+        fi
+    else
+        echo "Non-Debian based Linux detected. Please ensure libcurl development libraries are installed."
+    fi
+
 elif [[ "$OSTYPE" == "msys" || "$OSTYPE" == "win32" ]]; then
     # Windows
     MINICONDA_URL="https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe"
@@ -44,7 +58,6 @@ if conda info --envs | grep -q $ENV_NAME; then
         # Linux
         conda create --name $ENV_NAME python=3.10 pytorch=2.3.0 cudatoolkit=11.8 -c pytorch -c nvidia -y
     fi
-    # conda activate $ENV_NAME
 else
     echo "Creating new environment $ENV_NAME..."
     if [[ "$OSTYPE" == "darwin"* ]]; then
@@ -54,19 +67,25 @@ else
         # Linux
         conda create --name $ENV_NAME python=3.10 pytorch=2.3.0 cudatoolkit=11.8 -c pytorch -c nvidia -y
     fi
-    # conda activate $ENV_NAME
 fi
 
-# source $HOME/miniconda/bin/activate $ENV_NAME
+# Activate the environment
+source $HOME/miniconda/bin/activate $ENV_NAME
+
+# Install cmake via conda
+echo "Installing cmake..."
+conda install -y cmake
 
-# Get full path of pip
+# Get full path of pip within the activated environment
 PIP_FULL_PATH=$(conda run -n $ENV_NAME which pip)
 
-# Install other packages within the activated environment
-# Use PIP_FULL_PATH to run pip commands
+# Install other packages within the activated environment using pip
 $PIP_FULL_PATH install --upgrade pip 
 $PIP_FULL_PATH install "xformers==0.0.26.post1"
-$PIP_FULL_PATH install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git@4e570be9ae4ced8cdc64e498125708e34942befc"
+$PIP_FULL_PATH install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git@038e6d4c8d40207a87297ab3aaf787c19b1006d1"
 $PIP_FULL_PATH install --no-deps "trl<0.9.0" peft accelerate bitsandbytes 
+$PIP_FULL_PATH install unsloth_zoo
+$PIP_FULL_PATH install cut_cross_entropy
+$PIP_FULL_PATH install sentencepiece protobuf datasets huggingface_hub hf_transfer
 
 echo "Setup completed successfully!"

praisonai-2.0.64/praisonai/train.py

@@ -0,0 +1,374 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+This script finetunes a model using Unsloth’s fast training framework.
+It supports both ShareGPT and Alpaca‑style datasets by converting raw conversation
+data into plain-text prompts using a chat template, then pre‑tokenizing the prompts.
+Extra debug logging is added to help trace the root cause of errors.
+"""
+
+import os
+import sys
+import yaml
+import torch
+import shutil
+import subprocess
+from transformers import TextStreamer
+from unsloth import FastLanguageModel, is_bfloat16_supported
+from trl import SFTTrainer
+from transformers import TrainingArguments
+from datasets import load_dataset, concatenate_datasets
+from psutil import virtual_memory
+from unsloth.chat_templates import standardize_sharegpt, get_chat_template
+from functools import partial
+
+#####################################
+# Step 1: Formatting Raw Conversations
+#####################################
+def formatting_prompts_func(examples, tokenizer):
+    """
+    Converts each example’s conversation into a single plain-text prompt.
+    If the example has a "conversations" field, process it as ShareGPT-style.
+    Otherwise, assume Alpaca-style data with "instruction", "input", and "output" fields.
+    """
+    print("DEBUG: formatting_prompts_func() received batch with keys:", list(examples.keys()))
+    texts = []
+    # Check if the example has a "conversations" field.
+    if "conversations" in examples:
+        for convo in examples["conversations"]:
+            try:
+                formatted = tokenizer.apply_chat_template(
+                    convo,
+                    tokenize=False,  # Return a plain string
+                    add_generation_prompt=False
+                )
+            except Exception as e:
+                print(f"ERROR in apply_chat_template (conversations): {e}")
+                formatted = ""
+            # Flatten list if necessary
+            if isinstance(formatted, list):
+                formatted = formatted[0] if len(formatted) == 1 else "\n".join(formatted)
+            texts.append(formatted)
+    else:
+        # Assume Alpaca format: use "instruction", "input", and "output" keys.
+        instructions = examples.get("instruction", [])
+        inputs_list = examples.get("input", [])
+        outputs_list = examples.get("output", [])
+        # If any field is missing, replace with empty string.
+        for ins, inp, out in zip(instructions, inputs_list, outputs_list):
+            # Create a conversation-like structure.
+            convo = [
+                {"role": "user", "content": ins + (f"\nInput: {inp}" if inp.strip() != "" else "")},
+                {"role": "assistant", "content": out}
+            ]
+            try:
+                formatted = tokenizer.apply_chat_template(
+                    convo,
+                    tokenize=False,
+                    add_generation_prompt=False
+                )
+            except Exception as e:
+                print(f"ERROR in apply_chat_template (alpaca): {e}")
+                formatted = ""
+            if isinstance(formatted, list):
+                formatted = formatted[0] if len(formatted) == 1 else "\n".join(formatted)
+            texts.append(formatted)
+    if texts:
+        print("DEBUG: Raw texts sample (first 200 chars):", texts[0][:200])
+    return {"text": texts}
+
+#####################################
+# Step 2: Tokenizing the Prompts
+#####################################
+def tokenize_function(examples, hf_tokenizer, max_length):
+    """
+    Tokenizes a batch of text prompts with padding and truncation enabled.
+    """
+    flat_texts = []
+    for t in examples["text"]:
+        if isinstance(t, list):
+            t = t[0] if len(t) == 1 else " ".join(t)
+        flat_texts.append(t)
+    print("DEBUG: Tokenizing a batch of size:", len(flat_texts))
+    tokenized = hf_tokenizer(
+        flat_texts,
+        padding="max_length",
+        truncation=True,
+        max_length=max_length,
+        return_tensors="pt",
+    )
+    tokenized = {key: value.tolist() for key, value in tokenized.items()}
+    sample_key = list(tokenized.keys())[0]
+    print("DEBUG: Tokenized sample (first 10 tokens of", sample_key, "):", tokenized[sample_key][0][:10])
+    return tokenized
+
+#####################################
+# Main Training Class
+#####################################
+class TrainModel:
+    def __init__(self, config_path="config.yaml"):
+        self.load_config(config_path)
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model = None
+        self.hf_tokenizer = None   # The underlying HF tokenizer
+        self.chat_tokenizer = None # Chat wrapper for formatting
+
+    def load_config(self, path):
+        with open(path, "r") as file:
+            self.config = yaml.safe_load(file)
+        print("DEBUG: Loaded config:", self.config)
+
+    def print_system_info(self):
+        print("DEBUG: PyTorch version:", torch.__version__)
+        print("DEBUG: CUDA version:", torch.version.cuda)
+        if torch.cuda.is_available():
+            print("DEBUG: CUDA Device Capability:", torch.cuda.get_device_capability())
+        else:
+            print("DEBUG: CUDA is not available")
+        print("DEBUG: Python Version:", sys.version)
+        print("DEBUG: Python Path:", sys.executable)
+
+    def check_gpu(self):
+        gpu_stats = torch.cuda.get_device_properties(0)
+        print(f"DEBUG: GPU = {gpu_stats.name}. Max memory = {round(gpu_stats.total_memory/(1024**3),3)} GB.")
+
+    def check_ram(self):
+        ram_gb = virtual_memory().total / 1e9
+        print(f"DEBUG: Your runtime has {ram_gb:.1f} gigabytes of available RAM")
+        if ram_gb < 20:
+            print("DEBUG: Not using a high-RAM runtime")
+        else:
+            print("DEBUG: You are using a high-RAM runtime!")
+
+    def prepare_model(self):
+        print("DEBUG: Preparing model and tokenizer...")
+        self.model, original_tokenizer = FastLanguageModel.from_pretrained(
+            model_name=self.config["model_name"],
+            max_seq_length=self.config["max_seq_length"],
+            dtype=None,
+            load_in_4bit=self.config["load_in_4bit"],
+        )
+        print("DEBUG: Model and original tokenizer loaded.")
+        if original_tokenizer.pad_token is None:
+            original_tokenizer.pad_token = original_tokenizer.eos_token
+        original_tokenizer.model_max_length = self.config["max_seq_length"]
+        self.chat_tokenizer = get_chat_template(original_tokenizer, chat_template="llama-3.1")
+        self.hf_tokenizer = original_tokenizer
+        print("DEBUG: Chat tokenizer created; HF tokenizer saved.")
+        self.model = FastLanguageModel.get_peft_model(
+            self.model,
+            r=16,
+            target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
+            lora_alpha=16,
+            lora_dropout=0,
+            bias="none",
+            use_gradient_checkpointing="unsloth",
+            random_state=3407,
+            use_rslora=False,
+            loftq_config=None,
+        )
+        print("DEBUG: LoRA adapters added.")
+
+    def process_dataset(self, dataset_info):
+        dataset_name = dataset_info["name"]
+        split_type = dataset_info.get("split_type", "train")
+        print(f"DEBUG: Loading dataset '{dataset_name}' split '{split_type}'...")
+        dataset = load_dataset(dataset_name, split=split_type)
+        print("DEBUG: Dataset columns:", dataset.column_names)
+        if "conversations" in dataset.column_names:
+            print("DEBUG: Standardizing dataset (ShareGPT style)...")
+            dataset = standardize_sharegpt(dataset)
+        else:
+            print("DEBUG: Dataset does not have 'conversations'; assuming Alpaca format.")
+        print("DEBUG: Applying formatting function to dataset...")
+        format_func = partial(formatting_prompts_func, tokenizer=self.chat_tokenizer)
+        dataset = dataset.map(format_func, batched=True, remove_columns=dataset.column_names)
+        sample = dataset[0]
+        print("DEBUG: Sample processed example keys:", list(sample.keys()))
+        if "text" in sample:
+            print("DEBUG: Sample processed 'text' type:", type(sample["text"]))
+            print("DEBUG: Sample processed 'text' content (first 200 chars):", sample["text"][:200])
+        else:
+            print("DEBUG: Processed sample does not contain 'text'.")
+        return dataset
+
+    def tokenize_dataset(self, dataset):
+        print("DEBUG: Tokenizing the entire dataset...")
+        tokenized_dataset = dataset.map(
+            lambda examples: tokenize_function(examples, self.hf_tokenizer, self.config["max_seq_length"]),
+            batched=True
+        )
+        tokenized_dataset = tokenized_dataset.remove_columns(["text"])
+        print("DEBUG: Tokenized dataset sample keys:", tokenized_dataset[0].keys())
+        return tokenized_dataset
+
+    def load_datasets(self):
+        datasets = []
+        for dataset_info in self.config["dataset"]:
+            print("DEBUG: Processing dataset info:", dataset_info)
+            datasets.append(self.process_dataset(dataset_info))
+        combined = concatenate_datasets(datasets)
+        print("DEBUG: Combined dataset has", len(combined), "examples.")
+        return combined
+
+    def train_model(self):
+        print("DEBUG: Starting training...")
+        raw_dataset = self.load_datasets()
+        tokenized_dataset = self.tokenize_dataset(raw_dataset)
+        print("DEBUG: Dataset tokenization complete.")
+        training_args = TrainingArguments(
+            per_device_train_batch_size=2,
+            gradient_accumulation_steps=4,
+            warmup_steps=5,
+            max_steps=60,
+            learning_rate=2e-4,
+            fp16=not is_bfloat16_supported(),
+            bf16=is_bfloat16_supported(),
+            logging_steps=1,
+            optim="adamw_8bit",
+            weight_decay=0.01,
+            lr_scheduler_type="linear",
+            seed=3407,
+            output_dir="outputs",
+            report_to="none",
+            remove_unused_columns=False,
+        )
+        # Since the dataset is pre-tokenized, we supply a dummy dataset_text_field.
+        trainer = SFTTrainer(
+            model=self.model,
+            tokenizer=self.hf_tokenizer,
+            train_dataset=tokenized_dataset,
+            dataset_text_field="input_ids",  # Dummy field since data is numeric
+            max_seq_length=self.config["max_seq_length"],
+            dataset_num_proc=1,  # Use a single process to avoid pickling issues
+            packing=False,
+            args=training_args,
+        )
+        from unsloth.chat_templates import train_on_responses_only
+        trainer = train_on_responses_only(
+            trainer,
+            instruction_part="<|start_header_id|>user<|end_header_id|>\n\n",
+            response_part="<|start_header_id|>assistant<|end_header_id|>\n\n",
+        )
+        print("DEBUG: Beginning trainer.train() ...")
+        trainer.train()
+        print("DEBUG: Training complete. Saving model and tokenizer locally...")
+        self.model.save_pretrained("lora_model")
+        self.hf_tokenizer.save_pretrained("lora_model")
+        print("DEBUG: Saved model and tokenizer to 'lora_model'.")
+
+    def inference(self, instruction, input_text):
+        FastLanguageModel.for_inference(self.model)
+        messages = [{"role": "user", "content": f"{instruction}\n\nInput: {input_text}"}]
+        inputs = self.hf_tokenizer.apply_chat_template(
+            messages,
+            tokenize=True,
+            add_generation_prompt=True,
+            return_tensors="pt"
+        ).to("cuda")
+        outputs = self.model.generate(
+            input_ids=inputs,
+            max_new_tokens=64,
+            use_cache=True,
+            temperature=1.5,
+            min_p=0.1
+        )
+        print("DEBUG: Inference output:", self.hf_tokenizer.batch_decode(outputs))
+
+    def load_model(self):
+        from unsloth import FastLanguageModel
+        model, tokenizer = FastLanguageModel.from_pretrained(
+            model_name=self.config["output_dir"],
+            max_seq_length=2048,
+            dtype=None,
+            load_in_4bit=self.config["load_in_4bit"],
+        )
+        return model, tokenizer
+
+    def save_model_merged(self):
+        if os.path.exists(self.config["hf_model_name"]):
+            shutil.rmtree(self.config["hf_model_name"])
+        self.model.push_to_hub_merged(
+            self.config["hf_model_name"],
+            self.hf_tokenizer,
+            save_method="merged_16bit",
+            token=os.getenv("HF_TOKEN")
+        )
+
+    def push_model_gguf(self):
+        self.model.push_to_hub_gguf(
+            self.config["hf_model_name"],
+            self.hf_tokenizer,
+            quantization_method=self.config["quantization_method"],
+            token=os.getenv("HF_TOKEN")
+        )
+
+    def save_model_gguf(self):
+        self.model.save_pretrained_gguf(
+            self.config["hf_model_name"],
+            self.hf_tokenizer,
+            quantization_method="q4_k_m"
+        )
+
+    def prepare_modelfile_content(self):
+        output_model = self.config["hf_model_name"]
+        gguf_path = f"{output_model}/unsloth.Q4_K_M.gguf"
+        if not os.path.exists(gguf_path):
+            self.model, self.hf_tokenizer = self.load_model()
+            self.save_model_gguf()
+        return f"""FROM {output_model}/unsloth.Q4_K_M.gguf
+
+TEMPLATE \"\"\"Below are some instructions that describe some tasks. Write responses that appropriately complete each request.{{{{ if .Prompt }}}}
+
+### Instruction:
+{{{{ .Prompt }}}}
+
+{{{{ end }}}}### Response:
+{{{{ .Response }}}}\"\"\"
+
+PARAMETER stop ""
+PARAMETER stop ""
+PARAMETER stop ""
+PARAMETER stop ""
+PARAMETER stop "<|reserved_special_token_"
+"""
+
+    def create_and_push_ollama_model(self):
+        modelfile_content = self.prepare_modelfile_content()
+        with open("Modelfile", "w") as file:
+            file.write(modelfile_content)
+        subprocess.run(["ollama", "serve"])
+        subprocess.run(["ollama", "create", f"{self.config['ollama_model']}:{self.config['model_parameters']}", "-f", "Modelfile"])
+        subprocess.run(["ollama", "push", f"{self.config['ollama_model']}:{self.config['model_parameters']}"])
+
+    def run(self):
+        self.print_system_info()
+        self.check_gpu()
+        self.check_ram()
+        if self.config.get("train", "true").lower() == "true":
+            self.prepare_model()
+            self.train_model()
+        if self.config.get("huggingface_save", "true").lower() == "true":
+            self.save_model_merged()
+        if self.config.get("huggingface_save_gguf", "true").lower() == "true":
+            self.push_model_gguf()
+        if self.config.get("ollama_save", "true").lower() == "true":
+            self.create_and_push_ollama_model()
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description="PraisonAI Training Script")
+    parser.add_argument("command", choices=["train"], help="Command to execute")
+    parser.add_argument("--config", default="config.yaml", help="Path to configuration file")
+    parser.add_argument("--model", type=str, help="Model name")
+    parser.add_argument("--hf", type=str, help="Hugging Face model name")
+    parser.add_argument("--ollama", type=str, help="Ollama model name")
+    parser.add_argument("--dataset", type=str, help="Dataset name for training")
+    args = parser.parse_args()
+
+    if args.command == "train":
+        trainer_obj = TrainModel(config_path=args.config)
+        trainer_obj.run()
+
+if __name__ == "__main__":
+    main()

{praisonai-2.0.63 → praisonai-2.0.64}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "PraisonAI"
-version = "2.0.63"
+version = "2.0.64"
 description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration."
 readme = "README.md"
 license = ""
@@ -84,7 +84,7 @@ autogen = ["pyautogen>=0.2.19", "praisonai-tools>=0.0.7", "crewai"]
 
 [tool.poetry]
 name = "PraisonAI"
-version = "2.0.63"
+version = "2.0.64"
 description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human–agent collaboration."
 authors = ["Mervin Praison"]
 license = ""

praisonai-2.0.63/praisonai/train.py

@@ -1,276 +0,0 @@
-import subprocess
-import os
-import sys
-import yaml
-import torch
-import shutil
-from transformers import TextStreamer
-from unsloth import FastLanguageModel, is_bfloat16_supported
-from trl import SFTTrainer
-from transformers import TrainingArguments
-from datasets import load_dataset, concatenate_datasets, Dataset
-from psutil import virtual_memory
-
-class train:
-    def __init__(self, config_path="config.yaml"):
-        self.load_config(config_path)
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        self.model, self.tokenizer = None, None
-
-    def load_config(self, path):
-        with open(path, "r") as file:
-            self.config = yaml.safe_load(file)
-
-    def print_system_info(self):
-        print(f"PyTorch version: {torch.__version__}")
-        print(f"CUDA version: {torch.version.cuda}")
-        if torch.cuda.is_available():
-            device_capability = torch.cuda.get_device_capability()
-            print(f"CUDA Device Capability: {device_capability}")
-        else:
-            print("CUDA is not available")
-
-        python_version = sys.version
-        pip_version = subprocess.check_output(['pip', '--version']).decode().strip()
-        python_path = sys.executable
-        pip_path = subprocess.check_output(['which', 'pip']).decode().strip()
-        print(f"Python Version: {python_version}")
-        print(f"Pip Version: {pip_version}")
-        print(f"Python Path: {python_path}")
-        print(f"Pip Path: {pip_path}")
-
-    def check_gpu(self):
-        gpu_stats = torch.cuda.get_device_properties(0)
-        print(f"GPU = {gpu_stats.name}. Max memory = {round(gpu_stats.total_memory / 1024 / 1024 / 1024, 3)} GB.")
-
-    def check_ram(self):
-        ram_gb = virtual_memory().total / 1e9
-        print('Your runtime has {:.1f} gigabytes of available RAM\n'.format(ram_gb))
-        if ram_gb < 20:
-            print('Not using a high-RAM runtime')
-        else:
-            print('You are using a high-RAM runtime!')
-
-    # def install_packages(self):
-    #     subprocess.run(["pip", "install", "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git@4e570be9ae4ced8cdc64e498125708e34942befc"])
-    #     subprocess.run(["pip", "install", "--no-deps", "trl<0.9.0", "peft==0.12.0", "accelerate==0.33.0", "bitsandbytes==0.43.3"])
-
-    def prepare_model(self):
-        self.model, self.tokenizer = FastLanguageModel.from_pretrained(
-            model_name=self.config["model_name"],
-            max_seq_length=self.config["max_seq_length"],
-            dtype=None,
-            load_in_4bit=self.config["load_in_4bit"]
-        )
-        self.model = FastLanguageModel.get_peft_model(
-            self.model,
-            r=self.config["lora_r"],
-            target_modules=self.config["lora_target_modules"],
-            lora_alpha=self.config["lora_alpha"],
-            lora_dropout=self.config["lora_dropout"],
-            bias=self.config["lora_bias"],
-            use_gradient_checkpointing=self.config["use_gradient_checkpointing"],
-            random_state=self.config["random_state"],
-            use_rslora=self.config["use_rslora"],
-            loftq_config=self.config["loftq_config"],
-        )
-
-    def process_dataset(self, dataset_info):
-        dataset_name = dataset_info["name"]
-        split_type = dataset_info.get("split_type", "train")
-        processing_func = getattr(self, dataset_info.get("processing_func", "format_prompts"))
-        rename = dataset_info.get("rename", {})
-        filter_data = dataset_info.get("filter_data", False)
-        filter_column_value = dataset_info.get("filter_column_value", "id")
-        filter_value = dataset_info.get("filter_value", "alpaca")
-        num_samples = dataset_info.get("num_samples", 20000)
-
-        dataset = load_dataset(dataset_name, split=split_type)
-
-        if rename:
-            dataset = dataset.rename_columns(rename)
-        if filter_data:
-            dataset = dataset.filter(lambda example: filter_value in example[filter_column_value]).shuffle(seed=42).select(range(num_samples))
-        dataset = dataset.map(processing_func, batched=True)
-        return dataset
-
-    def format_prompts(self, examples):
-        alpaca_prompt = """Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.
-
-        ### Instruction:
-        {}
-
-        ### Input:
-        {}
-
-        ### Response:
-        {}"""
-        texts = [alpaca_prompt.format(ins, inp, out) + self.tokenizer.eos_token for ins, inp, out in zip(examples["instruction"], examples["input"], examples["output"])]
-        return {"text": texts}
-
-    def load_datasets(self):
-        datasets = []
-        for dataset_info in self.config["dataset"]:
-            datasets.append(self.process_dataset(dataset_info))
-        return concatenate_datasets(datasets)
-
-    def train_model(self):
-        dataset = self.load_datasets()
-        trainer = SFTTrainer(
-            model=self.model,
-            tokenizer=self.tokenizer,
-            train_dataset=dataset,
-            dataset_text_field=self.config["dataset_text_field"],
-            max_seq_length=self.config["max_seq_length"],
-            dataset_num_proc=self.config["dataset_num_proc"],
-            packing=self.config["packing"],
-            args=TrainingArguments(
-                per_device_train_batch_size=self.config["per_device_train_batch_size"],
-                gradient_accumulation_steps=self.config["gradient_accumulation_steps"],
-                warmup_steps=self.config["warmup_steps"],
-                num_train_epochs=self.config["num_train_epochs"],
-                max_steps=self.config["max_steps"],
-                learning_rate=self.config["learning_rate"],
-                fp16=not is_bfloat16_supported(),
-                bf16=is_bfloat16_supported(),
-                logging_steps=self.config["logging_steps"],
-                optim=self.config["optim"],
-                weight_decay=self.config["weight_decay"],
-                lr_scheduler_type=self.config["lr_scheduler_type"],
-                seed=self.config["seed"],
-                output_dir=self.config["output_dir"],
-            ),
-        )
-        trainer.train()
-        self.model.save_pretrained("lora_model") # Local saving
-        self.tokenizer.save_pretrained("lora_model")
-
-    def inference(self, instruction, input_text):
-        FastLanguageModel.for_inference(self.model)
-        alpaca_prompt = """Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.
-
-        ### Instruction:
-        {}
-
-        ### Input:
-        {}
-
-        ### Response:
-        {}"""
-        inputs = self.tokenizer([alpaca_prompt.format(instruction, input_text, "")], return_tensors="pt").to("cuda")
-        outputs = self.model.generate(**inputs, max_new_tokens=64, use_cache=True)
-        print(self.tokenizer.batch_decode(outputs))
-        
-    def load_model(self):
-        """Loads the model and tokenizer using the FastLanguageModel library."""
-        from unsloth import FastLanguageModel
-        model, tokenizer = FastLanguageModel.from_pretrained(
-            model_name=self.config["output_dir"],
-            max_seq_length=2048,
-            dtype=None,
-            load_in_4bit=self.config["load_in_4bit"],
-        )
-        return model, tokenizer
-
-    def save_model_merged(self):
-        if os.path.exists(self.config["hf_model_name"]):
-            shutil.rmtree(self.config["hf_model_name"])
-        self.model.push_to_hub_merged(
-            self.config["hf_model_name"],
-            self.tokenizer,
-            save_method="merged_16bit",
-            token=os.getenv('HF_TOKEN')
-        )
-
-    def push_model_gguf(self):
-        self.model.push_to_hub_gguf(
-            self.config["hf_model_name"],
-            self.tokenizer,
-            quantization_method=self.config["quantization_method"],
-            token=os.getenv('HF_TOKEN')
-        )
-    
-    def save_model_gguf(self):
-        self.model.save_pretrained_gguf(
-            self.config["hf_model_name"],
-            self.tokenizer,
-            quantization_method="q4_k_m"
-        )
-
-    def prepare_modelfile_content(self):
-        output_model = self.config["hf_model_name"]
-        gguf_path = f"{output_model}/unsloth.Q4_K_M.gguf"
-
-        # Check if the GGUF file exists. If not, generate it ## TODO Multiple Quantisation other than Q4_K_M.gguf
-        if not os.path.exists(gguf_path):
-            self.model, self.tokenizer = self.load_model()
-            self.save_model_gguf()
-        return f"""FROM {output_model}/unsloth.Q4_K_M.gguf
-
-TEMPLATE \"\"\"Below are some instructions that describe some tasks. Write responses that appropriately complete each request.{{{{ if .Prompt }}}}
-
-### Instruction:
-{{{{ .Prompt }}}}
-
-{{{{ end }}}}### Response:
-{{{{ .Response }}}}\"\"\"
-
-PARAMETER stop ""
-PARAMETER stop ""
-PARAMETER stop ""
-PARAMETER stop ""
-PARAMETER stop "<|reserved_special_token_"
-"""
-
-    def create_and_push_ollama_model(self):
-        modelfile_content = self.prepare_modelfile_content()
-        with open('Modelfile', 'w') as file:
-            file.write(modelfile_content)
-
-        subprocess.run(["ollama", "serve"])
-        subprocess.run(["ollama", "create", f"{self.config['ollama_model']}:{self.config['model_parameters']}", "-f", "Modelfile"])
-        subprocess.run(["ollama", "push", f"{self.config['ollama_model']}:{self.config['model_parameters']}"])
-
-    def run(self):
-        self.print_system_info()
-        self.check_gpu()
-        self.check_ram()
-        # self.install_packages()
-        if self.config.get("train", "true").lower() == "true":
-            self.prepare_model()
-            self.train_model()
-
-        if self.config.get("huggingface_save", "true").lower() == "true":
-            # self.model, self.tokenizer = self.load_model()
-            self.save_model_merged()
-
-        if self.config.get("huggingface_save_gguf", "true").lower() == "true":
-            # self.model, self.tokenizer = self.load_model()
-            self.push_model_gguf()
-            
-        # if self.config.get("save_gguf", "true").lower() == "true": ## TODO
-        #     self.model, self.tokenizer = self.load_model()
-        #     self.save_model_gguf()
-        
-        # if self.config.get("save_merged", "true").lower() == "true": ## TODO
-        #     self.model, self.tokenizer = self.load_model()
-        #     self.save_model_merged()
-
-        if self.config.get("ollama_save", "true").lower() == "true":
-            self.create_and_push_ollama_model()
-
-
-def main():
-    import argparse
-    parser = argparse.ArgumentParser(description='PraisonAI Training Script')
-    parser.add_argument('command', choices=['train'], help='Command to execute')
-    parser.add_argument('--config', default='config.yaml', help='Path to configuration file')
-    args = parser.parse_args()
-
-    if args.command == 'train':
-        ai = train(config_path=args.config)
-        ai.run()
-
-
-if __name__ == '__main__':
-    main()