Optymalizacja symulacji losowych przestojów w zakładach przemysłowych przy użyciu pand

Zwiększanie efektywności symulacji przestojów

Symulacja przypadkowych przestojów w zakładach przemysłowych jest zadaniem krytycznym zapewniającym optymalne planowanie operacyjne i zarządzanie ryzykiem. Każdy zakład może działać w trybie online lub offline, a generowanie danych szeregów czasowych reprezentujących tę dostępność może być wymagające obliczeniowo. Tradycyjnie powszechnym podejściem jest używanie natywnego języka Python do rysowania serii długości przestojów i odstępów między przerwami na podstawie rozkładów geometrycznych.

Jednak w przypadku skalowania tego do wielu zakładów proces staje się powolny i nieefektywny. W tym artykule omówiono, w jaki sposób możemy wykorzystać Pandy do przyspieszenia symulacji, wykorzystując jego potężne możliwości manipulacji danymi w celu usprawnienia generowania zestawów danych szeregów czasowych.

Komenda	Opis
pd.date_range()	Generuje zakres dat pomiędzy określoną datą początkową i końcową.
np.log()	Oblicza logarytm naturalny danych wejściowych używany do generowania próbek o rozkładzie geometrycznym.
random.random()	Zwraca losową liczbę zmiennoprzecinkową z zakresu od 0,0 do 1,0, używaną do generowania losowych prawdopodobieństw.
math.floor()	Zwraca największą liczbę całkowitą mniejszą lub równą określonej wartości, używaną do konwersji liczby zmiennoprzecinkowej na liczbę całkowitą.
math.ceil()	Zwraca najmniejszą liczbę całkowitą większą lub równą określonej wartości, używaną do zaokrąglenia w górę do najbliższej liczby całkowitej.
pd.DataFrame()	Tworzy obiekt DataFrame ze słownika, używany do organizowania danych tabelarycznych i manipulowania nimi.
extend()	Dołącza wiele pozycji na koniec listy, służy do jednoczesnego dodawania wielu stanów przestojów.
datetime()	Reprezentuje konkretną datę i godzinę służącą do definiowania dat rozpoczęcia i zakończenia symulacji.

Usprawniona symulacja awarii elektrowni za pomocą pand

Powyższe skrypty pokazują, jak efektywnie symulować przypadkowe przestoje w wielu zakładach przemysłowych przy użyciu Pand. Podstawowym celem jest generowanie danych szeregów czasowych odzwierciedlających dostępność każdego zakładu w trybie online (1) lub offline (0). Początkowo definiujemy okres symulacji za pomocą obiekty reprezentujące datę początkową i końcową. Ustawione są również stałe, takie jak średni czas przestoju i średni ułamek czasu offline. Korzystając z tych wartości, obliczamy parametry w szczególności rozkładów geometrycznych I , które pomogą w generowaniu losowych interwałów. Rdzeniem symulacji jest pętla generująca dane o przestojach dla każdej instalacji. W tej pętli używamy np.log I pobieranie próbek pod kątem długości przestojów i odstępów między przestojami. Próbki te są następnie wykorzystywane do codziennej aktualizacji stanu każdej instalacji. Jeśli instalacja jest w trybie offline, na czas przestoju status jest ustawiany na 0; w przeciwnym razie ustawiana jest na 1. Proces ten jest powtarzany aż do osiągnięcia okresu symulacji. Wygenerowane dane o stanie każdej instalacji są następnie przechowywane w Pandas DataFrame, co pozwala na efektywną manipulację danymi i ich analizę.

Drugi skrypt optymalizuje generowanie danych o przestojach poprzez hermetyzację logiki w funkcji o nazwie . Ta funkcja przebiega według tych samych kroków, ale jest bardziej modułowa i nadaje się do ponownego użycia, co pozwala na uzyskanie czystszego i łatwiejszego w utrzymaniu kodu. Funkcja generuje stan dostępności dla pojedynczego zakładu i zwraca listę przedstawiającą stan zakładu w okresie symulacji. Wywołując tę ​​funkcję w pętli dla wielu instalacji, wypełniamy ramkę DataFrame danymi o przestojach dla każdej instalacji. Sposób użycia aby utworzyć sekwencję dat i uporządkowanie danych zapewnia, że ​​symulacja jest zarówno wydajna, jak i łatwa do zrozumienia. Ostateczną ramkę danych można wykorzystać do dalszej analizy lub wizualizacji, dostarczając cennych informacji na temat wzorców dostępności zakładów przemysłowych.

import pandas as pd
import numpy as np
import random
import math
from datetime import datetime, timedelta

# Constants
SIMULATION_START_DATE = datetime(2024, 1, 1)
SIMULATION_END_DATE = datetime(2025, 1, 1)
mean_outage_duration = 3
mean_fraction_offline = 0.05

# Simulation Parameters
days_in_simulation = (SIMULATION_END_DATE - SIMULATION_START_DATE).days
outage_length_mu = -1 / mean_outage_duration
between_outages_mu = -1 / (days_in_simulation * mean_fraction_offline)

# DataFrame to hold the time-series data
plants = 10  # Number of plants
data = pd.DataFrame({'day': pd.date_range(start=SIMULATION_START_DATE, end=SIMULATION_END_DATE)})
for plant in range(plants):
    status = []
    sum_of_days = 0
    while sum_of_days < days_in_simulation:
        outage_length = math.floor(np.log(1 - random.random()) / outage_length_mu)
        days_until_next_outage = math.ceil(np.log(1 - random.random()) / between_outages_mu)
        if random.random() > mean_fraction_offline:
            days_until_next_outage = 0
        sum_of_days += days_until_next_outage
        for _ in range(days_until_next_outage):
            if sum_of_days >= days_in_simulation:
                break
            status.append(1)
            sum_of_days += 1
        for _ in range(outage_length):
            if sum_of_days >= days_in_simulation:
                break
            status.append(0)
            sum_of_days += 1
    data[f'plant_{plant}'] = status[:days_in_simulation]

print(data.head())

import pandas as pd
import numpy as np
import random
from datetime import datetime, timedelta

# Constants
SIMULATION_START_DATE = datetime(2024, 1, 1)
SIMULATION_END_DATE = datetime(2025, 1, 1)
mean_outage_duration = 3
mean_fraction_offline = 0.05

# Simulation Parameters
days_in_simulation = (SIMULATION_END_DATE - SIMULATION_START_DATE).days
outage_length_mu = -1 / mean_outage_duration
between_outages_mu = -1 / (days_in_simulation * mean_fraction_offline)

# Function to generate a single plant's outage data
def generate_outages():
    status = []
    sum_of_days = 0
    while sum_of_days < days_in_simulation:
        outage_length = math.floor(np.log(1 - random.random()) / outage_length_mu)
        days_until_next_outage = math.ceil(np.log(1 - random.random()) / between_outages_mu)
        if random.random() > mean_fraction_offline:
            days_until_next_outage = 0
        sum_of_days += days_until_next_outage
        status.extend([1] * min(days_until_next_outage, days_in_simulation - sum_of_days))
        sum_of_days += outage_length
        status.extend([0] * min(outage_length, days_in_simulation - sum_of_days))
    return status[:days_in_simulation]

# Generate DataFrame for multiple plants
plants = 10
data = pd.DataFrame({'day': pd.date_range(start=SIMULATION_START_DATE, end=SIMULATION_END_DATE)})
for plant in range(plants):
    data[f'plant_{plant}'] = generate_outages()

print(data.head())

Optymalizacja symulacji przestojów za pomocą zaawansowanych technik Pand

Oprócz podstawowej symulacji szeregów czasowych przy użyciu Pand, istnieje kilka zaawansowanych technik i funkcjonalności, które mogą dodatkowo zoptymalizować proces. Jedną z takich technik jest wektoryzacja, która polega na wykonywaniu operacji na całych tablicach zamiast iterowania po poszczególnych elementach. Wykorzystując operacje wektoryzowane w Pandach, możemy znacznie przyspieszyć proces symulacji przestojów. Takie podejście zmniejsza obciążenie pętli Pythona i w pełni wykorzystuje wewnętrzne optymalizacje Pand. Kolejnym kluczowym aspektem jest wydajna obsługa dużych zbiorów danych. W przypadku symulacji wielu zakładów przez dłuższy czas niezbędne staje się zarządzanie pamięcią. Korzystanie z typów danych zużywających mniej pamięci, takich jak kategoryczny typ danych Pandy dla stanów instalacji, może prowadzić do znacznej poprawy wydajności. Ponadto stosowanie technik takich jak dzielenie na porcje, w przypadku których zbiór danych jest przetwarzany w mniejszych porcjach, może pomóc w skutecznym zarządzaniu wykorzystaniem pamięci i zapobieganiu potencjalnym problemom z przepełnieniem pamięci podczas symulacji.

Co więcej, integracja innych bibliotek, takich jak NumPy i SciPy, może zwiększyć funkcjonalność i wydajność symulacji przestojów. Na przykład funkcje losowego próbkowania NumPy są wysoce zoptymalizowane i można ich używać do wydajniejszego generowania długości i interwałów przestojów. SciPy zapewnia zaawansowane funkcje statystyczne, które mogą być korzystne w przypadku bardziej złożonych symulacji. Połączenie tych bibliotek z Pandas pozwala na stworzenie solidniejszego i skalowalnego środowiska symulacyjnego, zdolnego do obsługi różnych scenariuszy i zapewniającego głębszy wgląd we wzorce dostępności zakładów.

1. Jakie są zalety używania Pand do symulacji przestojów?
2. Pandas oferuje wydajne możliwości manipulacji i analizy danych, umożliwiając szybszą symulację dużych zbiorów danych w porównaniu z natywnymi pętlami Pythona.
3. W jaki sposób wektoryzacja poprawia wydajność symulacji przestojów?
4. Wektoryzacja wykonuje operacje na całych tablicach jednocześnie, zmniejszając obciążenie pętli i wykorzystując wewnętrzne optymalizacje w Pandach.
5. Jaka jest rola w skrypcie symulacyjnym?
6. służy do obliczania logarytmu naturalnego, który pomaga generować próbki na podstawie rozkładu geometrycznego długości i odstępów między przestojami.
7. Dlaczego zarządzanie pamięcią jest ważne w symulacjach na dużą skalę?
8. Efektywne zarządzanie pamięcią zapobiega przepełnieniu pamięci i zapewnia płynne wykonanie, szczególnie podczas symulowania wielu zakładów przez dłuższy czas.
9. W jaki sposób kategoryczne typy danych w Pandach mogą pomóc w optymalizacji symulacji?
10. Kategoryczne typy danych zmniejszają zużycie pamięci poprzez bardziej efektywne reprezentowanie powtarzających się wartości, co jest korzystne przy obsłudze danych o stanie instalacji.
11. Jakie inne biblioteki mogą ulepszyć symulacje przestojów?
12. Biblioteki takie jak NumPy i SciPy zapewniają zoptymalizowane funkcje losowego próbkowania i analizy statystycznej, uzupełniając możliwości manipulacji danymi Pandy.
13. Czy można wykorzystać fragmentację do zarządzania dużymi zbiorami danych w symulacjach przestojów?
14. Tak, przetwarzanie zbioru danych w mniejszych porcjach pomaga skutecznie zarządzać wykorzystaniem pamięci i zapewnia, że ​​symulacja może bez problemów obsłużyć duże zbiory danych.
15. Jakie są zalety integracji NumPy z Pandami do symulacji?
16. Zoptymalizowane funkcje próbkowania losowego NumPy mogą wydajniej generować długości i interwały przestojów, zwiększając ogólną wydajność symulacji.

Zastosowanie Pand do symulacji przypadkowych przestojów w zakładach przemysłowych znacznie zwiększa wydajność procesu. Wykorzystując potężne możliwości manipulacji danymi Pand, możemy generować dokładne dane w formie szeregów czasowych dotyczące dostępności instalacji. Takie podejście nie tylko poprawia szybkość symulacji, ale także zapewnia lepsze zarządzanie pamięcią i skalowalność. Korzystanie z wektoryzacji i integrowanie bibliotek, takich jak NumPy i SciPy, dodatkowo optymalizuje symulację, czyniąc ją niezawodną i skalowalną w przypadku dużych zbiorów danych. Ogólnie rzecz biorąc, Pandas zapewnia kompleksowe rozwiązanie do skutecznego symulowania i analizowania przestojów instalacji, umożliwiając lepsze planowanie operacyjne i zarządzanie ryzykiem.