Wikiszótár

Monte-Carlo-módszer

Magyar

Kiejtés

  • IPA: [ ˈmontɛt͡sɒrlomoːt͡sːɛr]

Főnév

Monte-Carlo-módszer

  1. (matematika, algoritmusok) A Monte-Carlo-módszer egy olyan sztochasztikus szimulációs módszer, amely számítástechnikai eszközök segítségével előállítja egy adott kísérlet végeredményét, ezek után az eredményként kapott numerikus jellemzőket feljegyzik és kiértékelik. Az eredmény hibájának meghatározása szórás kiszámításával történik. Az álvéletlenszámokat, melyek a kísérletekben szereplő valószínűségi változók értékei, számítógép állítja elő. Több programnyelv is tartalmaz ilyen álvéletlenszám-generátort, pl. a C programnyelv.

Monte-Carlo-módszer

A Monte-Carlo-módszer egy sztochasztikus (valószínűségi) numerikus technika, amely véletlenszerű minták generálásával becsül meg valószínűségi, matematikai vagy fizikai problémákat. A módszer nevét a Monte Carlo kaszinóról kapta, mivel erősen támaszkodik a véletlenszerűségre.


Fő jellemzők

  1. Véletlenszerű minták:
    • A Monte-Carlo-módszer véletlenszerű mintákat használ a problématér mintázására.
  2. Átlagolás:
    • Az eredmények átlaga a becsült érték közelítő eredményét adja.
  3. Alkalmazások:
    • Matematikai integrálás.
    • Valószínűségi eloszlások becslése.
    • Fizikai szimulációk (pl. részecskék mozgása).
    • Optimalizáció és kockázatmenedzsment.
  4. Pontosság:
    • A pontosság növelhető a minták számának növelésével ((N)). A hiba általában (O(1/)).


Algoritmus működése

1. Matematikai integrálás:

A Monte-Carlo-módszer használható egy adott (f(x)) függvény ([a, b]) intervallumban vett integráljának becslésére: [ I = _a^b f(x) , dx ]

Az algoritmus lépései: 1. Generálj (N) véletlenszerű számot az ([a, b]) intervallumban. 2. Számítsd ki (f(x))-et minden véletlen (x) értékre. 3. Az integrál közelítése: [ I (b - a) _{i=1}^N f(x_i) ]


Pszeudokód

MonteCarloIntegrálás(f, a, b, N):
    sum = 0
    ismételj N-szer:
        x = véletlen szám [a, b]-ben
        sum = sum + f(x)
    térj vissza (b - a) * (sum / N)

Python implementáció

1. Egyszerű integrálás

import random

def monte_carlo_integration(f, a, b, N):
    total = 0
    for _ in range(N):
        x = random.uniform(a, b)  # Véletlen szám [a, b]-ben
        total += f(x)
    return (b - a) * (total / N)

# Példa: integrálás [0, 1] intervallumban, f(x) = x^2
f = lambda x: x**2
a, b = 0, 1
N = 10000

result = monte_carlo_integration(f, a, b, N)
print("Monte-Carlo becslés:", result)

Kimenet (példa): 

Monte-Carlo becslés: 0.33345

(A pontos érték: (1/3 ))


2. Kör területének becslése

A Monte-Carlo-módszer segítségével becsülhető () értéke úgy, hogy egy egységkör területét közelítjük a véletlenszerű pontok alapján. 

import random

def estimate_pi(num_points):
    inside_circle = 0

    for _ in range(num_points):
        x, y = random.uniform(0, 1), random.uniform(0, 1)  # Véletlen pontok [0, 1] négyzetben
        if x**2 + y**2 <= 1:  # Ellenőrzés, hogy a pont az egységkörben van-e
            inside_circle += 1

    return (inside_circle / num_points) * 4

# Becsüljük meg pi értékét
N = 100000
pi_estimate = estimate_pi(N)
print("Pi becslés:", pi_estimate)

Kimenet (példa): 

Pi becslés: 3.1416

C++ implementáció

1. Egyszerű integrálás

#include <iostream>
#include <cmath>
#include <cstdlib>

double monte_carlo_integration(double (*f)(double), double a, double b, int N) {
    double total = 0.0;
    for (int i = 0; i < N; ++i) {
        double x = a + static_cast<double>(rand()) / RAND_MAX * (b - a);
        total += f(x);
    }
    return (b - a) * (total / N);
}

double function(double x) {
    return x * x;  // f(x) = x^2
}

int main() {
    double a = 0.0, b = 1.0;
    int N = 10000;

    double result = monte_carlo_integration(function, a, b, N);
    std::cout << "Monte-Carlo becslés: " << result << std::endl;

    return 0;
}

Kimenet: 

Monte-Carlo becslés: 0.33345

2. Kör területének becslése

#include <iostream>
#include <cstdlib>
#include <cmath>

double estimate_pi(int num_points) {
    int inside_circle = 0;

    for (int i = 0; i < num_points; ++i) {
        double x = static_cast<double>(rand()) / RAND_MAX;
        double y = static_cast<double>(rand()) / RAND_MAX;

        if (x * x + y * y <= 1.0) {
            inside_circle++;
        }
    }

    return 4.0 * inside_circle / num_points;
}

int main() {
    int N = 100000;
    double pi_estimate = estimate_pi(N);
    std::cout << "Pi becslés: " << pi_estimate << std::endl;

    return 0;
}

Kimenet: 

Pi becslés: 3.1416

Összegzés

Előnyök:

  1. Egyszerűség: Könnyen implementálható és alkalmazható komplex problémákra.
  2. Általánosíthatóság: Különböző valószínűségi és matematikai problémákra használható.
  3. Párhuzamosítható: A véletlenszerű minták függetlensége lehetővé teszi a párhuzamos számítást.

Hátrányok:

  1. Lassú konvergencia: A pontosság növeléséhez sok minta szükséges ((O(1/))).
  2. Véletlenszám-generátorok minősége: A pontosság függ a véletlenszám-generátor minőségétől.

A Monte-Carlo-módszer különösen hasznos olyan problémák esetén, amelyek determinisztikus módszerekkel nehezen vagy egyáltalán nem oldhatók meg. Az egyszerűsége és széles körű alkalmazhatósága miatt a numerikus matematikában, szimulációkban és mesterséges intelligenciában is gyakran használják.

Fordítások

További információk

A lap eredeti címe: „https://hu.wiktionary.org/w/index.php?title=Monte-Carlo-módszer&oldid=3479532”