Đánh Giá Năng Lực Tổ Chức AI: Hành Trình Chuyển Đổi Từ Hệ Thống Cũ Sang HolySheep AI

Trong bối cảnh AI ngày càng trở thành yếu tố cốt lõi của mọi doanh nghiệp số, việc đánh giá năng lực tổ chức AI không chỉ là xu hướng mà đã trở thành nhu cầu tất yếu. Bài viết này sẽ chia sẻ câu chuyện thực tế của một startup AI tại Hà Nội và hành trình họ đã thực hiện để tối ưu hóa hệ thống đánh giá năng lực tổ chức của mình.

Bối Cảnh Khách Hàng

Một startup AI chuyên cung cấp giải pháp đánh giá nhân sự dựa trên trí tuệ nhân tạo tại Hà Nội đã phải đối mặt với thách thức nghiêm trọng về chi phí và hiệu suất. Với hơn 50 doanh nghiệp khách hàng và hàng ngàn bài đánh giá mỗi ngày, hệ thống cũ của họ sử dụng API từ nhà cung cấp quốc tế với độ trễ trung bình 420ms và chi phí hàng tháng lên đến $4,200.

Điểm đau lớn nhất của startup này không chỉ nằm ở chi phí cao mà còn ở sự phụ thuộc vào hạ tầng bên ngoài với độ tin cậy không ổn định, ảnh hưởng trực tiếp đến trải nghiệm người dùng cuối và uy tín thương hiệu.

Tại Sao Chọn HolySheep AI?

Sau khi nghiên cứu kỹ lưỡng các giải pháp thay thế, đội ngũ kỹ thuật đã quyết định chuyển đổi sang HolySheep AI với những lý do chính:

• Tiết kiệm 85%+ chi phí - Với tỷ giá chỉ ¥1=$1, giá thành API cực kỳ cạnh tranh
• Độ trễ dưới 50ms - Đảm bảo trải nghiệm người dùng mượt mà
• Tín dụng miễn phí khi đăng ký - Giảm thiểu rủi ro khi thử nghiệm
• Hỗ trợ WeChat/Alipay - Thuận tiện cho thanh toán quốc tế

Các Bước Triển Khai Chi Tiết

Bước 1: Cấu Hình API Client

Đầu tiên, đội ngũ kỹ thuật đã thiết lập client mới sử dụng base_url của HolySheep AI. Dưới đây là cấu hình hoàn chỉnh:

import requests
import time
from typing import Dict, List, Optional
import json

class HolySheepAIClient:
    """Client cho HolySheep AI API - Đánh giá năng lực tổ chức AI"""
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.holysheep.ai/v1"
        self.headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
    
    def evaluate_organization_capability(
        self, 
        org_data: Dict,
        evaluation_framework: str = "standard"
    ) -> Dict:
        """
        Đánh giá năng lực tổ chức AI
        
        Args:
            org_data: Dữ liệu tổ chức bao gồm:
                - employee_count: Số lượng nhân viên
                - tech_stack: Stack công nghệ đang sử dụng
                - ai_maturity: Mức độ trưởng thành AI (1-5)
                - budget_allocation: Ngân sách phân bổ cho AI
                - data_infrastructure: Hạ tầng dữ liệu
            evaluation_framework: Khung đánh giá (standard/advanced/custom)
        
        Returns:
            Dict chứa kết quả đánh giá năng lực
        """
        prompt = self._build_evaluation_prompt(org_data, evaluation_framework)
        
        payload = {
            "model": "gpt-4.1",
            "messages": [
                {
                    "role": "system", 
                    "content": "Bạn là chuyên gia tư vấn AI chiến lược với 15 năm kinh nghiệm đánh giá năng lực tổ chức AI cho các doanh nghiệp Việt Nam."
                },
                {
                    "role": "user",
                    "content": prompt
                }
            ],
            "temperature": 0.3,
            "max_tokens": 2000
        }
        
        start_time = time.time()
        
        try:
            response = requests.post(
                f"{self.base_url}/chat/completions",
                headers=self.headers,
                json=payload,
                timeout=30
            )
            response.raise_for_status()
            
            result = response.json()
            latency_ms = (time.time() - start_time) * 1000
            
            return {
                "success": True,
                "evaluation": result["choices"][0]["message"]["content"],
                "latency_ms": round(latency_ms, 2),
                "tokens_used": result.get("usage", {}).get("total_tokens", 0),
                "model": result.get("model", "unknown")
            }
            
        except requests.exceptions.Timeout:
            return {
                "success": False,
                "error": "Request timeout - thử lại với cấu hình khác",
                "latency_ms": (time.time() - start_time) * 1000
            }
        except requests.exceptions.RequestException as e:
            return {
                "success": False,
                "error": str(e),
                "latency_ms": (time.time() - start_time) * 1000
            }
    
    def _build_evaluation_prompt(
        self, 
        org_data: Dict, 
        framework: str
    ) -> str:
        """Xây dựng prompt đánh giá theo framework"""
        
        templates = {
            "standard": """
            Hãy đánh giá năng lực AI của tổ chức dựa trên dữ liệu sau:
            
            1. Quy mô nhân sự: {employee_count} người
            2. Stack công nghệ: {tech_stack}
            3. Mức độ trưởng thành AI: {ai_maturity}/5
            4. Ngân sách AI: ${budget} USD/tháng
            5. Hạ tầng dữ liệu: {data_infra}
            
            Đánh giá theo các tiêu chí:
            - Năng lực kỹ thuật (điểm từ 1-10)
            - Văn hóa AI (điểm từ 1-10)
            - Chiến lược AI (điểm từ 1-10)
            - Hạ tầng và dữ liệu (điểm từ 1-10)
            
            Đưa ra:
            1. Điểm tổng hợp và xếp hạng (A/B/C/D)
            2. 3 điểm mạnh chính
            3. 3 điểm cần cải thiện
            4. Lộ trình hành động 90 ngày
            """,
            
            "advanced": """
            Phân tích chuyên sâu năng lực AI tổ chức:
            
            {org_data}
            
            Yêu cầu:
            - Phân tích SWOT chi tiết
            - So sánh benchmark ngành
            - Đề xuất use case AI ưu tiên
            - Ước tính ROI khi triển khai AI
            """
        }
        
        template = templates.get(framework, templates["standard"])
        
        return template.format(
            employee_count=org_data.get("employee_count", 0),
            tech_stack=", ".join(org_data.get("tech_stack", [])),
            ai_maturity=org_data.get("ai_maturity", 1),
            budget=org_data.get("budget_allocation", 0),
            data_infra=org_data.get("data_infrastructure", "basic"),
            org_data=json.dumps(org_data, indent=2, ensure_ascii=False)
        )

Sử dụng client
client = HolySheepAIClient(api_key="YOUR_HOLYSHEEP_API_KEY")

Dữ liệu tổ chức cần đánh giá
org_sample = {
    "employee_count": 150,
    "tech_stack": ["Python", "AWS", "PostgreSQL", "React"],
    "ai_maturity": 3,
    "budget_allocation": 5000,
    "data_infrastructure": "cloud-native"
}

result = client.evaluate_organization_capability(org_sample)
print(f"Độ trễ: {result['latency_ms']}ms")
print(f"Kết quả: {result['evaluation']}")

Bước 2: Xoay Vòng API Keys và Retry Logic

Để đảm bảo high availability, đội ngũ đã triển khai hệ thống xoay vòng API keys với retry logic thông minh:

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
import time
from concurrent.futures import ThreadPoolExecutor, as_completed
import threading

class HolySheepLoadBalancer:
    """Load balancer cho HolySheep AI với xoay vòng keys"""
    
    def __init__(self, api_keys: List[str]):
        self.api_keys = api_keys
        self.current_key_index = 0
        self.key_usage_count = {key: 0 for key in api_keys}
        self.key_lock = threading.Lock()
        self.session = self._create_session()
    
    def _create_session(self) -> requests.Session:
        """Tạo session với retry strategy"""
        session = requests.Session()
        
        retry_strategy = Retry(
            total=3,
            backoff_factor=0.5,
            status_forcelist=[429, 500, 502, 503, 504],
            allowed_methods=["POST", "GET"]
        )
        
        adapter = HTTPAdapter(
            max_retries=retry_strategy,
            pool_connections=10,
            pool_maxsize=20
        )
        
        session.mount("https://", adapter)
        session.mount("http://", adapter)
        
        return session
    
    def _get_next_key(self) -> str:
        """Lấy key tiếp theo theo round-robin"""
        with self.key_lock:
            key = self.api_keys[self.current_key_index]
            self.key_usage_count[key] += 1
            self.current_key_index = (self.current_key_index + 1) % len(self.api_keys)
            return key
    
    def _make_request_with_key(
        self,
        key: str,
        payload: dict,
        timeout: int = 30
    ) -> dict:
        """Thực hiện request với key cụ thể"""
        headers = {
            "Authorization": f"Bearer {key}",
            "Content-Type": "application/json"
        }
        
        start_time = time.time()
        
        try:
            response = self.session.post(
                "https://api.holysheep.ai/v1/chat/completions",
                headers=headers,
                json=payload,
                timeout=timeout
            )
            response.raise_for_status()
            
            latency_ms = (time.time() - start_time) * 1000
            
            return {
                "success": True,
                "data": response.json(),
                "latency_ms": round(latency_ms, 2),
                "key_index": self.api_keys.index(key)
            }
            
        except requests.exceptions.Timeout:
            return {
                "success": False,
                "error": "timeout",
                "latency_ms": (time.time() - start_time) * 1000
            }
        except requests.exceptions.RequestException as e:
            return {
                "success": False,
                "error": str(e),
                "latency_ms": (time.time() - start_time) * 1000
            }
    
    def batch_evaluate(
        self,
        organizations: List[dict],
        max_workers: int = 5
    ) -> List[dict]:
        """Đánh giá hàng loạt nhiều tổ chức song song"""
        
        def evaluate_single(org: dict, index: int) -> dict:
            key = self._get_next_key()
            
            payload = {
                "model": "deepseek-v3.2",
                "messages": [
                    {
                        "role": "system",
                        "content": "Đánh giá năng lực AI tổ chức"
                    },
                    {
                        "role": "user",
                        "content": f"Đánh giá tổ chức: {org.get('name', 'Unknown')}\n"
                                  f"Mô tả: {org.get('description', 'N/A')}"
                    }
                ],
                "temperature": 0.3,
                "max_tokens": 1000
            }
            
            result = self._make_request_with_key(key, payload)
            result["organization_index"] = index
            result["organization_name"] = org.get("name", "Unknown")
            
            return result
        
        results = []
        
        with ThreadPoolExecutor(max_workers=max_workers) as executor:
            futures = {
                executor.submit(evaluate_single, org, i): i 
                for i, org in enumerate(organizations)
            }
            
            for future in as_completed(futures):
                try:
                    result = future.result()
                    results.append(result)
                except Exception as e:
                    results.append({
                        "success": False,
                        "error": str(e)
                    })
        
        # Sắp xếp theo thứ tự ban đầu
        results.sort(key=lambda x: x.get("organization_index", 0))
        
        return results

Sử dụng load balancer với nhiều API keys
api_keys = [
    "YOUR_HOLYSHEEP_API_KEY_1",
    "YOUR_HOLYSHEEP_API_KEY_2",
    "YOUR_HOLYSHEEP_API_KEY_3"
]

lb = HolySheepLoadBalancer(api_keys)

Đánh giá hàng loạt 10 tổ chức
organizations = [
    {"name": f"Công ty {i}", "description": "Mô tả công ty"}
    for i in range(10)
]

results = lb.batch_evaluate(organizations, max_workers=5)

Thống kê hiệu suất
success_count = sum(1 for r in results if r.get("success"))
avg_latency = sum(r.get("latency_ms", 0) for r in results if r.get("success")) / max(success_count, 1)

print(f"Tỷ lệ thành công: {success_count}/{len(results)}")
print(f"Độ trễ trung bình: {avg_latency:.2f}ms")

Bước 3: Triển Khai Canary Deployment

Để giảm thiểu rủi ro khi chuyển đổi, đội ngũ đã triển khai canary deployment với traffic splitting thông minh:

import random
from enum import Enum
from typing import Callable, Any, Optional
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class DeploymentEnvironment(Enum):
    """Môi trường deployment"""
    OLD = "old_provider"
    NEW = "holy_sheep"
    CANARY = "canary"

class CanaryDeployment:
    """Canary deployment với traffic splitting"""
    
    def __init__(
        self,
        old_client,
        new_client,
        canary_percentage: float = 10.0
    ):
        self.old_client = old_client
        self.new_client = new_client
        self.canary_percentage = canary_percentage
        self.metrics = {
            "old": {"success": 0, "failed": 0, "total_latency": 0},
            "new": {"success": 0, "failed": 0, "total_latency": 0}
        }
    
    def _get_environment(self) -> DeploymentEnvironment:
        """Xác định môi trường thực thi dựa trên canary percentage"""
        rand = random.uniform(0, 100)
        
        if rand < self.canary_percentage:
            return DeploymentEnvironment.CANARY
        else:
            return DeploymentEnvironment.OLD
    
    def evaluate(
        self,
        org_data: dict,
        force_environment: Optional[DeploymentEnvironment] = None
    ) -> dict:
        """
        Đánh giá năng lực tổ chức với canary deployment
        
        Args:
            org_data: Dữ liệu tổ chức
            force_environment: Bắt buộc sử dụng môi trường cụ thể
        
        Returns:
            Kết quả đánh giá kèm metadata
        """
        env = force_environment or self._get_environment()
        
        start_time = time.time()
        success = False
        error = None
        result_data = None
        
        try:
            if env == DeploymentEnvironment.CANARY:
                logger.info("🚀 Sử dụng HolySheep AI (canary)")
                result_data = self.new_client.evaluate_organization_capability(org_data)
                success = result_data.get("success", False)
                
                if success:
                    self.metrics["new"]["success"] += 1
                    self.metrics["new"]["total_latency"] += result_data.get("latency_ms", 0)
                else:
                    self.metrics["new"]["failed"] += 1
                    error = result_data.get("error")
            else:
                logger.info("📦 Sử dụng provider cũ")
                result_data = self.old_client.evaluate(org_data)
                success = result_data.get("success", False)
                
                if success:
                    self.metrics["old"]["success"] += 1
                    self.metrics["old"]["total_latency"] += result_data.get("latency_ms", 0)
                else:
                    self.metrics["old"]["failed"] += 1
                    error = result_data.get("error")
        
        except Exception as e:
            error = str(e)
            logger.error(f"Lỗi đánh giá: {error}")
        
        latency_ms = (time.time() - start_time) * 1000
        
        return {
            "success": success,
            "environment": env.value,
            "result": result_data,
            "latency_ms": round(latency_ms, 2),
            "error": error
        }
    
    def get_metrics_report(self) -> dict:
        """Tạo báo cáo metrics so sánh"""
        
        def calc_stats(env_metrics: dict) -> dict:
            total = env_metrics["success"] + env_metrics["failed"]
            success_rate = env_metrics["success"] / total if total > 0 else 0
            avg_latency = env_metrics["total_latency"] / env_metrics["success"] if env_metrics["success"] > 0 else 0
            
            return {
                "total_requests": total,
                "success_rate": round(success_rate * 100, 2),
                "avg_latency_ms": round(avg_latency, 2)
            }
        
        return {
            "old_provider": calc_stats(self.metrics["old"]),
            "holy_sheep": calc_stats(self.metrics["new"]),
            "improvement": self._calculate_improvement()
        }
    
    def _calculate_improvement(self) -> dict:
        """Tính toán cải thiện khi chuyển sang HolySheep"""
        
        old_stats = self.metrics["old"]
        new_stats = self.metrics["new"]
        
        if old_stats["success"] == 0 or new_stats["success"] == 0:
            return {"status": "insufficient_data"}
        
        old_avg_latency = old_stats["total_latency"] / old_stats["success"]
        new_avg_latency = new_stats["total_latency"] / new_stats["success"]
        
        latency_improvement = ((old_avg_latency - new_avg_latency) / old_avg_latency) * 100
        
        return {
            "latency_improvement_percent": round(latency_improvement, 2),
            "old_avg_latency_ms": round(old_avg_latency, 2),
            "new_avg_latency_ms": round(new_avg_latency, 2)
        }

Sử dụng canary deployment
canary = CanaryDeployment(
    old_client=old_provider_client,
    new_client=holy_sheep_client,
    canary_percentage=10.0
)

Chạy 1000 requests để test
for i in range(1000):
    org_data = generate_sample_org()
    result = canary.evaluate(org_data)

Báo cáo kết quả
report = canary.get_metrics_report()
print(f"Báo cáo Canary Deployment:")
print(f"- Provider cũ: {report['old_provider']['avg_latency_ms']}ms trung bình")
print(f"- HolySheep AI: {report['holy_sheep']['avg_latency_ms']}ms trung bình")
print(f"- Cải thiện: {report['improvement']['latency_improvement_percent']}%")

Kết Quả Sau 30 Ngày Go-Live

Sau khi triển khai đầy đủ, startup AI tại Hà Nội đã ghi nhận những cải thiện ấn tượng:

• Độ trễ trung bình: Giảm từ 420ms xuống còn 180ms (giảm 57%)
• Chi phí hàng tháng: Giảm từ $4,200 xuống còn $680 (tiết kiệm 84%)
• Uptime: Tăng từ 99.2% lên 99.9%
• Throughput: Tăng 3 lần với cùng cấu hình hạ tầng

Bảng Giá So Sánh Chi Tiết

Dưới đây là bảng so sánh chi phí giữa nhà cung cấp cũ và HolySheep AI:

Model	Nhà cung cấp cũ ($/MTok)	HolySheep AI ($/MTok)	Tiết kiệm
GPT-4.1	$30.00	$8.00	73%
Claude Sonnet 4.5	$45.00	$15.00	67%
Gemini 2.5 Flash	$7.50	$2.50	67%
DeepSeek V3.2	$2.80	$0.42	85%

Với tỷ giá chỉ ¥1=$1, HolySheep AI mang đến mức giá thấp nhất thị trường cho mọi doanh nghiệp Việt Nam muốn xây dựng hệ thống đánh giá năng lực tổ chức AI chuyên nghiệp.

Lỗi Thường Gặp và Cách Khắc Phục

Qua quá trình triển khai thực tế, đội ngũ kỹ thuật đã tổng hợp 5 lỗi phổ biến nhất khi làm việc với HolySheep AI API:

1. Lỗi Authentication Failed

Mô tả lỗi: Request trả về HTTP 401 với thông báo "Invalid API key"

Nguyên nhân: API key không đúng định dạng hoặc đã bị revoke

Mã khắc phục:

import os

def validate_api_key(api_key: str) -> bool:
    """Validate API key trước khi sử dụng"""
    
    # Kiểm tra format cơ bản
    if not api_key or len(api_key) < 20:
        print("❌ API key không hợp lệ - quá ngắn")
        return False
    
    # Kiểm tra prefix
    valid_prefixes = ["hs_", "sk-"]
    if not any(api_key.startswith(p) for p in valid_prefixes):
        print("⚠️ Cảnh báo: API key không có prefix chuẩn")
        # Vẫn cho phép tiếp tục nếu key có thể valid
    
    # Test request
    import requests
    
    headers = {"Authorization": f"Bearer {api_key}"}
    
    try:
        response = requests.post(
            "https://api.holysheep.ai/v1/chat/completions",
            headers=headers,
            json={
                "model": "deepseek-v3.2",
                "messages": [{"role": "user", "content": "test"}],
                "max_tokens": 5
            },
            timeout=10
        )
        
        if response.status_code == 401:
            print("❌ Authentication failed - API key không hợp lệ")
            return False
        elif response.status_code == 200:
            print("✅ API key hợp lệ")
            return True
        else:
            print(f"⚠️ Response không mong đợi: {response.status_code}")
            return False
            
    except requests.exceptions.Timeout:
        print("❌ Timeout khi validate API key")
        return False
    except Exception as e:
        print(f"❌ Lỗi validate: {e}")
        return False

Sử dụng
API_KEY = os.getenv("HOLYSHEEP_API_KEY", "YOUR_HOLYSHEEP_API_KEY")
if validate_api_key(API_KEY):
    print("Sẵn sàng sử dụng HolySheep AI")
else:
    print("Vui lòng kiểm tra API key tại: https://www.holysheep.ai/register")

2. Lỗi Rate Limit Exceeded

Mô tả lỗi: Request trả về HTTP 429 với thông báo "Rate limit exceeded"

Nguyên nhân: Vượt quá số lượng request cho phép trong thời gian ngắn

Mã khắc phục:

import time
import asyncio
from collections import deque
from threading import Lock

class RateLimiter:
    """Rate limiter với token bucket algorithm"""
    
    def __init__(self, requests_per_minute: int = 60):
        self.requests_per_minute = requests_per_minute
        self.request_times = deque()
        self.lock = Lock()
    
    def wait_if_needed(self) -> float:
        """
        Chờ nếu cần thiết để không vượt rate limit
        Returns: Thời gian đã chờ (seconds)
        """
        with self.lock:
            current_time = time.time()
            
            # Loại bỏ requests cũ hơn 1 phút
            while self.request_times and current_time - self.request_times[0] > 60:
                self.request_times.popleft()
            
            # Kiểm tra nếu đã đạt rate limit
            if len(self.request_times) >= self.requests_per_minute:
                oldest_request = self.request_times[0]
                wait_time = 60 - (current_time - oldest_request) + 0.1
                
                if wait_time > 0:
                    print(f"⏳ Rate limit reached. Chờ {wait_time:.2f}s...")
                    time.sleep(wait_time)
                    return wait_time
            
            # Ghi nhận request hiện tại
            self.request_times.append(time.time())
            return 0
    
    async def async_wait_if_needed(self) -> float:
        """Phiên bản async của wait_if_needed"""
        wait_time = self.wait_if_needed()
        if wait_time > 0:
            await asyncio.sleep(wait_time)
        return wait_time

class HolySheepRateLimitedClient:
    """Client với rate limiting tự động"""
    
    def __init__(self, api_key: str, rpm: int = 60):
        self.api_key = api_key
        self.base_url = "https://api.holysheep.ai/v1"
        self.rate_limiter = RateLimiter(rpm)
        self.total_requests = 0
        self.rate_limited_requests = 0
    
    def chat_completion(self, messages: list, model: str = "deepseek-v3.2") -> dict:
        """Gửi chat completion với rate limiting tự động"""
        
        # Đợi nếu cần thiết
        wait_time = self.rate_limiter.wait_if_needed()
        self.total_requests += 1
        
        if wait_time > 0:
            self.rate_limited_requests += 1
        
        import requests
        
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": model,
            "messages": messages,
            "max_tokens": 1000
        }
        
        try:
            response = requests.post(
                f"{self.base_url}/chat/completions",
                headers=headers,
                json=payload,
                timeout=30
            )
            
            if response.status_code == 429:
                # Nếu vẫn bị rate limit, chờ thêm
                retry_after = int(response.headers.get("Retry-After", 60))
                print(f"🔄 Bị rate limit. Chờ {retry_after}s...")
                time.sleep(retry_after)
                
                # Thử lại
                response = requests.post(
                    f"{self.base_url}/chat/completions",
                    headers=headers,
                    json=payload,
                    timeout=30
                )
            
            response.raise_for_status()
            return {"success": True, "data": response.json()}
            
        except requests.exceptions.RequestException as e:
            return {"success": False, "error": str(e)}
    
    def get_stats(self) -> dict:
        """Lấy thống kê sử dụng"""
        return {
            "total_requests": self.total_requests,
            "rate_limited_count": self.rate_limited_requests,
            "rate_limit_rate": round(
                self.rate_limited_requests / max(self.total_requests, 1) * 100, 2
            )
        }

Sử dụng client với rate limiting
client = HolySheepRateLimitedClient(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    rpm=60  # 60 requests/phút
)

Gửi 100 requests
for i in range(100):
    result = client.chat_completion([
        {"role": "user", "content": f"Tính toán {i}"}
    ])
    print(f"Request {i+1}: {'✅' if result['success'] else '❌'}")

print(f"\n📊 Thống kê: {client.get_stats()}")

3. Lỗi Timeout Khi Xử Lý Batch Lớn

Mô tả lỗi: Các batch requests lớn thường xuyên bị timeout

Nguyên nhân: Kích thước payload quá lớn hoặc server bận

Mã khắc ph