PraisonAI 2.0.62__cp313-cp313-manylinux_2_39_x86_64.whl → 2.0.64__cp313-cp313-manylinux_2_39_x86_64.whl

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)
@@ -140,6 +146,8 @@ class PraisonAI:
         provided arguments.
         """
         args = self.parse_args()
+        # Store args for use in handle_direct_prompt
+        self.args = args
         invocation_cmd = "praisonai"
         version_string = f"PraisonAI version {__version__}"
 
@@ -304,6 +312,7 @@ class PraisonAI:
         parser.add_argument("command", nargs="?", help="Command to run or direct prompt")
         parser.add_argument("--deploy", action="store_true", help="Deploy the application")
         parser.add_argument("--model", type=str, help="Model name")
+        parser.add_argument("--llm", type=str, help="LLM model to use for direct prompts")
         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", default="yahma/alpaca-cleaned")
@@ -390,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:
@@ -424,21 +437,33 @@ class PraisonAI:
         Handle direct prompt by creating a single agent and running it.
         """
         if PRAISONAI_AVAILABLE:
-            agent = PraisonAgent(
-                name="DirectAgent",
-                role="Assistant",
-                goal="Complete the given task",
-                backstory="You are a helpful AI assistant"
-            )
-            agent.start(prompt)
+            agent_config = {
+                "name": "DirectAgent",
+                "role": "Assistant",
+                "goal": "Complete the given task",
+                "backstory": "You are a helpful AI assistant"
+            }
+            
+            # Add llm if specified
+            if hasattr(self, 'args') and self.args.llm:
+                agent_config["llm"] = self.args.llm
+            
+            agent = PraisonAgent(**agent_config)
+            result = agent.start(prompt)
             return ""
         elif CREWAI_AVAILABLE:
-            agent = Agent(
-                name="DirectAgent",
-                role="Assistant",
-                goal="Complete the given task",
-                backstory="You are a helpful AI assistant"
-            )
+            agent_config = {
+                "name": "DirectAgent",
+                "role": "Assistant",
+                "goal": "Complete the given task",
+                "backstory": "You are a helpful AI assistant"
+            }
+            
+            # Add llm if specified
+            if hasattr(self, 'args') and self.args.llm:
+                agent_config["llm"] = self.args.llm
+            
+            agent = Agent(**agent_config)
             task = Task(
                 description=prompt,
                 agent=agent
@@ -450,6 +475,10 @@ class PraisonAI:
             return crew.kickoff()
         elif AUTOGEN_AVAILABLE:
             config_list = self.config_list
+            # Add llm if specified
+            if hasattr(self, 'args') and self.args.llm:
+                config_list[0]['model'] = self.args.llm
+                
             assistant = autogen.AssistantAgent(
                 name="DirectAgent",
                 llm_config={"config_list": config_list}

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.62 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/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/train.py

@@ -1,168 +1,281 @@
-import subprocess
+#!/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, Dataset
+from datasets import load_dataset, concatenate_datasets
 from psutil import virtual_memory
-
-class train:
+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, self.tokenizer = None, None
+        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(f"PyTorch version: {torch.__version__}")
-        print(f"CUDA version: {torch.version.cuda}")
+        print("DEBUG: PyTorch version:", torch.__version__)
+        print("DEBUG: CUDA version:", torch.version.cuda)
         if torch.cuda.is_available():
-            device_capability = torch.cuda.get_device_capability()
-            print(f"CUDA Device Capability: {device_capability}")
+            print("DEBUG: CUDA Device Capability:", torch.cuda.get_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}")
+            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"GPU = {gpu_stats.name}. Max memory = {round(gpu_stats.total_memory / 1024 / 1024 / 1024, 3)} GB.")
+        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('Your runtime has {:.1f} gigabytes of available RAM\n'.format(ram_gb))
+        print(f"DEBUG: Your runtime has {ram_gb:.1f} gigabytes of available RAM")
         if ram_gb < 20:
-            print('Not using a high-RAM runtime')
+            print("DEBUG: 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"])
+            print("DEBUG: You are using a high-RAM runtime!")
 
     def prepare_model(self):
-        self.model, self.tokenizer = FastLanguageModel.from_pretrained(
+        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"]
+            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=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"],
+            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")
-        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)
-
+        print(f"DEBUG: Loading dataset '{dataset_name}' split '{split_type}'...")
         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)
+        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 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 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))
-        return concatenate_datasets(datasets)
+        combined = concatenate_datasets(datasets)
+        print("DEBUG: Combined dataset has", len(combined), "examples.")
+        return combined
 
     def train_model(self):
-        dataset = self.load_datasets()
+        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.tokenizer,
-            train_dataset=dataset,
-            dataset_text_field=self.config["dataset_text_field"],
+            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=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"],
-            ),
+            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()
-        self.model.save_pretrained("lora_model") # Local saving
-        self.tokenizer.save_pretrained("lora_model")
+        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)
-        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:
-        {}
+        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))
 
-        ### 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"],
@@ -177,33 +290,31 @@ class train:
             shutil.rmtree(self.config["hf_model_name"])
         self.model.push_to_hub_merged(
             self.config["hf_model_name"],
-            self.tokenizer,
+            self.hf_tokenizer,
             save_method="merged_16bit",
-            token=os.getenv('HF_TOKEN')
+            token=os.getenv("HF_TOKEN")
         )
 
     def push_model_gguf(self):
         self.model.push_to_hub_gguf(
             self.config["hf_model_name"],
-            self.tokenizer,
+            self.hf_tokenizer,
             quantization_method=self.config["quantization_method"],
-            token=os.getenv('HF_TOKEN')
+            token=os.getenv("HF_TOKEN")
         )
-    
+
     def save_model_gguf(self):
         self.model.save_pretrained_gguf(
             self.config["hf_model_name"],
-            self.tokenizer,
+            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"
-
-        # 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.model, self.hf_tokenizer = self.load_model()
             self.save_model_gguf()
         return f"""FROM {output_model}/unsloth.Q4_K_M.gguf
 
@@ -224,9 +335,8 @@ PARAMETER stop "<|reserved_special_token_"
 
     def create_and_push_ollama_model(self):
         modelfile_content = self.prepare_modelfile_content()
-        with open('Modelfile', 'w') as file:
+        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']}"])
@@ -235,42 +345,30 @@ PARAMETER stop "<|reserved_special_token_"
         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')
+    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':
-        ai = train(config_path=args.config)
-        ai.run()
-
+    if args.command == "train":
+        trainer_obj = TrainModel(config_path=args.config)
+        trainer_obj.run()
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

{praisonai-2.0.62.dist-info → praisonai-2.0.64.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: PraisonAI
-Version: 2.0.62
+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.62.dist-info → praisonai-2.0.64.dist-info}/RECORD

@@ -4,8 +4,8 @@ praisonai/agents_generator.py,sha256=j8lYudAr3wlVBQLng3iYL6mfRqx2i9M6wlryxIVRzDA
 praisonai/api/call.py,sha256=krOfTCZM_bdbsNuWQ1PijzCHECkDvEi9jIvvZaDQUUU,11035
 praisonai/auto.py,sha256=uLDm8CU3L_3amZsd55yzf9RdBF1uW-BGSx7nl9ctNZ4,8680
 praisonai/chainlit_ui.py,sha256=bNR7s509lp0I9JlJNvwCZRUZosC64qdvlFCt8NmFamQ,12216
-praisonai/cli.py,sha256=T4fXYBNNbrP-d05tZyyaCFv5yk1l8m5Tdq29UkUozEo,24129
-praisonai/deploy.py,sha256=-RfcWiORrXzvQulxuirz5_eNUWRp8DlZOiPU6_A2kZ4,6028
+praisonai/cli.py,sha256=C4MoIXaLHldRNYPqXpHPpD8DjJU2qUJqZMHzbem7te4,25254
+praisonai/deploy.py,sha256=iwY-SWVosSSDGSoHiX2k0ar1BGQee0rvyU8aTSD5IEA,6028
 praisonai/inbuilt_tools/__init__.py,sha256=fai4ZJIKz7-iOnGZv5jJX0wmT77PKa4x2jqyaJddKFA,569
 praisonai/inbuilt_tools/autogen_tools.py,sha256=kJdEv61BTYvdHOaURNEpBcWq8Rs-oC03loNFTIjT-ak,4687
 praisonai/inc/__init__.py,sha256=sPDlYBBwdk0VlWzaaM_lG0_LD07lS2HRGvPdxXJFiYg,62
@@ -30,10 +30,10 @@ praisonai/setup/build.py,sha256=NyTAXQ_UZ8vKo_KwCINp8ctmauZyCMDkw1rys3ay0ec,646
 praisonai/setup/config.yaml,sha256=sr_D1RIvv3LQ_eueOMZV0rAUiWTR-n2xuE1RhKK6b34,1211
 praisonai/setup/post_install.py,sha256=rlUYJhT4JXVrL2RQih5VUPr4PQEmpVypoRpe_vJDMBk,730
 praisonai/setup/setup_conda_env.py,sha256=4QiWrqgEObivzOMwfJgWaCPpUEpB68cQ6lFwVwFoufk,816
-praisonai/setup/setup_conda_env.sh,sha256=te7s0KHsTi7XM-vkNvE0dKC1HeU2tXxqE-sPUScV6fY,2718
+praisonai/setup/setup_conda_env.sh,sha256=Xr9Az71A7jUozttnGQFHaUHIKZne4VIq9PPn6wrA18w,3466
 praisonai/setup.py,sha256=0jHgKnIPCtBZiGYaYyTz3PzrJI6nBy55VXk2UctXlDo,373
 praisonai/test.py,sha256=OL-wesjA5JTohr8rtr6kWoaS4ImkJg2l0GXJ-dUUfRU,4090
-praisonai/train.py,sha256=DvORlrwKOD-2v4r_z84eV3LsfzpNs-WnPKb5cQB3_t4,11071
+praisonai/train.py,sha256=m3-N2XWRernBWRg_xRr7bilxhq7WvFJYwxfvjROIjEw,15541
 praisonai/ui/README.md,sha256=QG9yucvBieVjCjWFzu6hL9xNtYllkoqyJ_q1b0YYAco,1124
 praisonai/ui/agents.py,sha256=1qsWE2yCaQKhuc-1uLHdMfZJeOXzBtp4pe5q7bk2EuA,32813
 praisonai/ui/callbacks.py,sha256=V4_-GjxmjDFmugUZGfQHKtNSysx7rT6i1UblbM_8lIM,1968
@@ -82,8 +82,8 @@ praisonai/ui/realtimeclient/tools.py,sha256=IJOYwVOBW5Ocn5_iV9pFkmSKR3WU3YpX3kwF
 praisonai/ui/sql_alchemy.py,sha256=oekZOXlRGMJ2SuC-lmgMMIzAmvbMg2DWeGTSpOzbVBM,29674
 praisonai/ui/tools.md,sha256=Ad3YH_ZCLMWlz3mDXllQnQ_S5l55LWqLdcZSh-EXrHI,3956
 praisonai/version.py,sha256=ugyuFliEqtAwQmH4sTlc16YXKYbFWDmfyk87fErB8-8,21
-praisonai-2.0.62.dist-info/LICENSE,sha256=kqvFysVlnFxYOu0HxCe2HlmZmJtdmNGOxWRRkT9TsWc,1035
-praisonai-2.0.62.dist-info/METADATA,sha256=TARzV6EAJ7_dEkYMRcJ2vj2AQ7fpDXTGNe9vsMGHNZQ,21885
-praisonai-2.0.62.dist-info/WHEEL,sha256=OiNztsphQWM3l0xJ9BHQRElMnxzHbt1M68r2N60f8T8,110
-praisonai-2.0.62.dist-info/entry_points.txt,sha256=I_xc6a6MNTTfLxYmAxe0rgey0G-_hbY07oFW-ZDnkw4,135
-praisonai-2.0.62.dist-info/RECORD,,
+praisonai-2.0.64.dist-info/LICENSE,sha256=kqvFysVlnFxYOu0HxCe2HlmZmJtdmNGOxWRRkT9TsWc,1035
+praisonai-2.0.64.dist-info/METADATA,sha256=V6BK_5k6vwE-jzCGo8ea1Y6o-afs4mIa2n1BVaayZKE,21942
+praisonai-2.0.64.dist-info/WHEEL,sha256=OiNztsphQWM3l0xJ9BHQRElMnxzHbt1M68r2N60f8T8,110
+praisonai-2.0.64.dist-info/entry_points.txt,sha256=I_xc6a6MNTTfLxYmAxe0rgey0G-_hbY07oFW-ZDnkw4,135
+praisonai-2.0.64.dist-info/RECORD,,