Whiz Tools

Máy Tính Z-Score

Giới thiệu

z-score (hay còn gọi là điểm chuẩn) là một phép đo thống kê mô tả mối quan hệ của một giá trị với trung bình của một nhóm giá trị. Nó chỉ ra số lượng độ lệch chuẩn mà một phần tử cách xa trung bình. Z-score là một công cụ quan trọng trong thống kê, cho phép chuẩn hóa các tập dữ liệu khác nhau và xác định các điểm ngoại lai.

Công thức

Z-score được tính bằng công thức sau:

z=xμσz = \frac{x - \mu}{\sigma}

Trong đó:

  • zz = z-score
  • xx = điểm dữ liệu cá nhân
  • μ\mu = trung bình của tập dữ liệu
  • σ\sigma = độ lệch chuẩn của tập dữ liệu

Công thức này tính toán số lượng độ lệch chuẩn mà một điểm dữ liệu cách xa trung bình.

Tính toán

Để tính toán z-score của một điểm dữ liệu:

  1. Tính Trung Bình (μ\mu):

    Cộng tất cả các điểm dữ liệu và chia cho số lượng điểm dữ liệu.

    μ=i=1nxin\mu = \frac{\sum_{i=1}^{n} x_i}{n}
  2. Tính Độ Lệch Chuẩn (σ\sigma):

    • Phương Sai (σ2\sigma^2):

      σ2=i=1n(xiμ)2n\sigma^2 = \frac{\sum_{i=1}^{n} (x_i - \mu)^2}{n}
    • Độ Lệch Chuẩn:

      σ=σ2\sigma = \sqrt{\sigma^2}
  3. Tính Z-Score:

    Thay thế các giá trị vào công thức z-score.

    z=xμσz = \frac{x - \mu}{\sigma}

Trường hợp đặc biệt

  • Độ lệch chuẩn bằng không (σ=0\sigma = 0):

    Khi tất cả các điểm dữ liệu đều giống nhau, độ lệch chuẩn bằng không, khiến z-score không xác định vì bạn không thể chia cho không. Trong trường hợp này, khái niệm z-score không áp dụng.

  • Điểm dữ liệu bằng trung bình (x=μx = \mu):

    Nếu điểm dữ liệu bằng trung bình, z-score bằng không, cho thấy nó hoàn toàn trung bình.

  • Đầu vào không phải số:

    Đảm bảo tất cả các đầu vào là số. Đầu vào không phải số sẽ dẫn đến lỗi tính toán.

Xác suất tích lũy

Xác suất tích lũy liên quan đến một z-score đại diện cho xác suất mà một biến ngẫu nhiên từ một phân phối chuẩn sẽ nhỏ hơn hoặc bằng giá trị đã cho. Đây là diện tích dưới đường cong phân phối chuẩn về phía bên trái của z-score đã chỉ định.

Về mặt toán học, xác suất tích lũy PP được tính bằng cách sử dụng hàm phân phối tích lũy (CDF) của phân phối chuẩn:

P(Zz)=Φ(z)=12πzet2/2dtP(Z \leq z) = \Phi(z) = \frac{1}{\sqrt{2\pi}} \int_{-\infty}^{z} e^{-t^2/2} \, dt

Trong đó:

  • Φ(z)\Phi(z) = CDF của phân phối chuẩn tại zz

Xác suất tích lũy rất quan trọng trong thống kê để xác định khả năng một giá trị xảy ra trong một khoảng nhất định. Nó được sử dụng rộng rãi trong các lĩnh vực như kiểm soát chất lượng, tài chính và khoa học xã hội.

Sơ đồ SVG

Dưới đây là một sơ đồ SVG minh họa đường cong phân phối chuẩn và z-score:

μ x z

Phân phối chuẩn

Hình: Đường cong phân phối chuẩn với Z-Score được tô bóng

Sơ đồ này cho thấy đường cong phân phối chuẩn với trung bình μ\mu ở giữa. Khu vực được tô bóng đại diện cho xác suất tích lũy đến điểm dữ liệu xx, tương ứng với z-score.

Các trường hợp sử dụng

Ứng dụng

  • Chuẩn hóa giữa các thang đo khác nhau:

    Z-score cho phép so sánh giữa dữ liệu từ các thang đo khác nhau bằng cách chuẩn hóa các tập dữ liệu.

  • Phát hiện điểm ngoại lai:

    Xác định các điểm dữ liệu cách xa trung bình một cách đáng kể (ví dụ: z-score nhỏ hơn -3 hoặc lớn hơn 3).

  • Kiểm tra thống kê:

    Sử dụng trong kiểm tra giả thuyết, bao gồm các bài kiểm tra z, để xác định xem một trung bình mẫu có khác biệt đáng kể so với một trung bình quần thể đã biết hay không.

  • Kiểm soát chất lượng:

    Trong sản xuất, z-score giúp theo dõi quy trình để đảm bảo sản phẩm đầu ra nằm trong giới hạn chấp nhận.

  • Tài chính và đầu tư:

    Đánh giá hiệu suất cổ phiếu bằng cách so sánh lợi nhuận tương đối với hiệu suất trung bình của thị trường.

Các phương án thay thế

  • T-Score:

    Tương tự như z-score nhưng được sử dụng khi kích thước mẫu nhỏ và độ lệch chuẩn quần thể không biết.

  • Xếp hạng phần trăm:

    Chỉ ra tỷ lệ phần trăm các điểm số trong phân phối tần suất mà nó bằng hoặc thấp hơn nó.

  • Đơn vị độ lệch chuẩn:

    Sử dụng các giá trị độ lệch chuẩn thô mà không chuẩn hóa thành z-score.

Lịch sử

Khái niệm về z-score xuất phát từ công trình về phân phối chuẩn của Carl Friedrich Gauss vào đầu thế kỷ 19. Phân phối chuẩn, nền tảng cho z-score, đã được phát triển thêm bởi các nhà thống kê như Abraham de Moivre và Pierre-Simon Laplace. Việc sử dụng z-score trở nên phổ biến với sự phát triển của các phương pháp thống kê trong thế kỷ 20, đặc biệt trong kiểm tra tâm lý và kiểm soát chất lượng.

Ví dụ

Excel

## Tính z-score trong Excel
## Giả sử điểm dữ liệu ở ô A2, trung bình ở ô B2, độ lệch chuẩn ở ô C2
=(A2 - B2) / C2

R

## Tính z-score trong R
calculate_z_score <- function(x, mean, sd) {
  if (sd == 0) {
    stop("Độ lệch chuẩn không thể bằng không.")
  }
  z <- (x - mean) / sd
  return(z)
}

## Ví dụ sử dụng:
x <- 85
mu <- 75
sigma <- 5
z_score <- calculate_z_score(x, mu, sigma)
print(paste("Z-score:", z_score))

MATLAB

% Tính z-score trong MATLAB
function z = calculate_z_score(x, mu, sigma)
    if sigma == 0
        error('Độ lệch chuẩn không thể bằng không.');
    end
    z = (x - mu) / sigma;
end

% Ví dụ sử dụng:
x = 90;
mu = 80;
sigma = 8;
z = calculate_z_score(x, mu, sigma);
fprintf('Z-score: %.2f\n', z);

JavaScript

// Tính z-score trong JavaScript
function calculateZScore(x, mu, sigma) {
  if (sigma === 0) {
    throw new Error('Độ lệch chuẩn không thể bằng không.');
  }
  return (x - mu) / sigma;
}

// Ví dụ sử dụng:
const x = 100;
const mu = 85;
const sigma = 7;
try {
  const z = calculateZScore(x, mu, sigma);
  console.log(`Z-score: ${z.toFixed(2)}`);
} catch (error) {
  console.error(error.message);
}

Python

## Tính z-score trong Python
def calculate_z_score(x, mu, sigma):
    if sigma == 0:
        raise ValueError("Độ lệch chuẩn không thể bằng không.")
    return (x - mu) / sigma

## Ví dụ sử dụng:
x = 95
mu = 88
sigma = 4
try:
    z = calculate_z_score(x, mu, sigma)
    print("Z-score:", round(z, 2))
except ValueError as e:
    print(e)

Java

// Tính z-score trong Java
public class ZScoreCalculator {
    public static double calculateZScore(double x, double mu, double sigma) {
        if (sigma == 0) {
            throw new IllegalArgumentException("Độ lệch chuẩn không thể bằng không.");
        }
        return (x - mu) / sigma;
    }

    public static void main(String[] args) {
        double x = 110;
        double mu = 100;
        double sigma = 5;

        try {
            double z = calculateZScore(x, mu, sigma);
            System.out.printf("Z-score: %.2f%n", z);
        } catch (IllegalArgumentException e) {
            System.err.println(e.getMessage());
        }
    }
}

C/C++

// Tính z-score trong C++
#include <iostream>
#include <stdexcept>

double calculate_z_score(double x, double mu, double sigma) {
    if (sigma == 0) {
        throw std::invalid_argument("Độ lệch chuẩn không thể bằng không.");
    }
    return (x - mu) / sigma;
}

int main() {
    double x = 130;
    double mu = 120;
    double sigma = 10;

    try {
        double z = calculate_z_score(x, mu, sigma);
        std::cout << "Z-score: " << z << std::endl;
    } catch (const std::exception &e) {
        std::cerr << e.what() << std::endl;
    }

    return 0;
}

Ruby

## Tính z-score trong Ruby
def calculate_z_score(x, mu, sigma)
  raise ArgumentError, "Độ lệch chuẩn không thể bằng không." if sigma == 0
  (x - mu) / sigma
end

## Ví dụ sử dụng:
x = 105
mu = 100
sigma = 5
begin
  z = calculate_z_score(x, mu, sigma)
  puts "Z-score: #{z.round(2)}"
rescue ArgumentError => e
  puts e.message
end

PHP

<?php
// Tính z-score trong PHP
function calculate_z_score($x, $mu, $sigma) {
  if ($sigma == 0) {
    throw new Exception("Độ lệch chuẩn không thể bằng không.");
  }
  return ($x - $mu) / $sigma;
}

// Ví dụ sử dụng:
$x = 115;
$mu = 110;
$sigma = 5;

try {
  $z = calculate_z_score($x, $mu, $sigma);
  echo "Z-score: " . round($z, 2);
} catch (Exception $e) {
  echo $e->getMessage();
}
?>

Rust

// Tính z-score trong Rust
fn calculate_z_score(x: f64, mu: f64, sigma: f64) -> Result<f64, String> {
    if sigma == 0.0 {
        return Err("Độ lệch chuẩn không thể bằng không.".to_string());
    }
    Ok((x - mu) / sigma)
}

fn main() {
    let x = 125.0;
    let mu = 115.0;
    let sigma = 5.0;

    match calculate_z_score(x, mu, sigma) {
        Ok(z) => println!("Z-score: {:.2}", z),
        Err(e) => println!("{}", e),
    }
}

C#

// Tính z-score trong C#
using System;

public class ZScoreCalculator
{
    public static double CalculateZScore(double x, double mu, double sigma)
    {
        if (sigma == 0)
            throw new ArgumentException("Độ lệch chuẩn không thể bằng không.");
        return (x - mu) / sigma;
    }

    public static void Main()
    {
        double x = 135;
        double mu = 125;
        double sigma = 5;

        try
        {
            double z = CalculateZScore(x, mu, sigma);
            Console.WriteLine($"Z-score: {z:F2}");
        }
        catch (ArgumentException e)
        {
            Console.WriteLine(e.Message);
        }
    }
}

Go

// Tính z-score trong Go
package main

import (
    "errors"
    "fmt"
)

func calculateZScore(x, mu, sigma float64) (float64, error) {
    if sigma == 0 {
        return 0, errors.New("độ lệch chuẩn không thể bằng không")
    }
    return (x - mu) / sigma, nil
}

func main() {
    x := 140.0
    mu := 130.0
    sigma := 5.0

    z, err := calculateZScore(x, mu, sigma)
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Printf("Z-score: %.2f\n", z)
    }
}

Swift

// Tính z-score trong Swift
func calculateZScore(x: Double, mu: Double, sigma: Double) throws -> Double {
    if sigma == 0 {
        throw NSError(domain: "Độ lệch chuẩn không thể bằng không.", code: 1, userInfo: nil)
    }
    return (x - mu) / sigma
}

// Ví dụ sử dụng:
let x = 120.0
let mu = 110.0
let sigma = 5.0

do {
    let z = try calculateZScore(x: x, mu: mu, sigma: sigma)
    print("Z-score: \(String(format: "%.2f", z))")
} catch let error as NSError {
    print(error.domain)
}

Tài liệu tham khảo

  1. Điểm chuẩn - Wikipedia

    https://en.wikipedia.org/wiki/Standard_score

  2. Hiểu về Z-Scores - Statistics Solutions

    https://www.statisticssolutions.com/understanding-z-scores/

  3. Phân phối chuẩn và Z-Scores - Khan Academy

    https://www.khanacademy.org/math/statistics-probability/modeling-distributions-of-data/z-scores/a/z-scores-review

Tài nguyên bổ sung

Feedback