शुरू करेंमुफ़्त में शुरू करें

मैन्युफैक्चरिंग ऑप्टिमाइज़ेशन: Score & Rank

आइए दीवार घड़ी फैक्टरी के उसी discrete-event मॉडल का उपयोग करें और एक "Score & Rank" ऑप्टिमाइज़ेशन रूटीन सेट करें. आपकी सुविधा के लिए, मैन्युफैक्चरिंग प्रोसेस नीचे दी गई तालिका में फिर से संक्षेपित किया गया है. यह जानकारी processes नाम की डिक्शनरीज़ की एक लिस्ट में स्टोर है, जिसमें प्रत्येक प्रोसेस के लिए एक डिक्शनरी है. इस डिक्शनरी की keys टेबल के कॉलम हेडर्स से मेल खाती हैं.

Table with process names and their duration statistics, namely mean and standard deviation.

इस अभ्यास में प्लॉट्स बनाने के लिए उपयोग की गई plot_results() मेथड पहले से लोड की गई है और नीचे दिखाई गई है.

def plot_results(objective_func):
    # Score
    fig, axes = plt.subplots(1, len(processes), sharey=True, figsize=(10, 8))
    for p in range(len(processes)):
        sns.scatterplot(ax=axes[p], x=process_duration_all[:, p], y=objective_func, c=objective_func, cmap="turbo_r")
        axes[p].set_title(processes[p]["Name"], rotation = 20, horizontalalignment='left')
        axes[p].set_xlabel("Duration [min]", rotation = -10)
        axes[p].grid()
    axes[0].set_ylabel("Objective function score")
    plt.show()

    # Rank
    index_sort = np.argsort(objective_func)
    fig, axes = plt.subplots(1, len(processes), sharey=True, figsize=(10, 8))
    for p in range(len(processes)):
        sns.lineplot(ax=axes[p], x=np.linspace(0, NUM_SIMULATIONS, NUM_SIMULATIONS),
                     y=process_duration_all[index_sort, p], color="orchid")
        axes[p].set_title(processes[p]["Name"], rotation = 20, horizontalalignment='left')
        axes[p].set_xlabel("Score-ranked scenarios", rotation = -10)
        axes[p].grid()
    axes[0].set_ylabel("Duration [min]")
    plt.show()

Monte-Carlo सैंपलिंग लूप संभावित प्रोसेस ट्रैजेक्टोरीज़ की एक सीरीज़ जनरेट करेगा और उन्हें स्कोर करेगा, जैसा कि फ़िगर में दिखाया गया है. Monte Carlo trajectories for different process scenario.

यह अभ्यास पाठ्यक्रम का हिस्सा है

Python में Discrete Event Simulation

पाठ्यक्रम देखें

अभ्यास निर्देश

  • हर प्रोसेस का स्कोर-योगदान जोड़ें. ध्यान रखें कि प्रोसेसेज़ की duration process_duration_all[s, p] में स्टोर है और उनके संबंधित weight proc_p["score_weight_0_10"] में हैं.
  • for loop को सेट करें ताकि वह NUM_SIMULATIONS Monte-Carlo रन चलाए, जहाँ s डमी वैरिएबल है.
  • Monte Carlo इंजन चलाएँ जो फंक्शन run_monte_carlo() में स्टोर है (यह "score" और "rank" दोनों प्लॉट्स जनरेट करेगा).

इंटरैक्टिव व्यावहारिक अभ्यास

इस अभ्यास को इस नमूना कोड को पूरा करके आज़माएँ।

def objective_function_calc():
    objective_func = np.ones(NUM_SIMULATIONS)

    for s in range(NUM_SIMULATIONS):
        for p in range(len(processes)):
            proc_p = processes[p]
            
            # Add the score contribution of each process
            objective_func[s] += ____

    plot_results(objective_func)

def run_monte_carlo():

    # Set the for-loop to run NUM_SIMULATIONS Monte-Carlo runs 
    ____

        env = simpy.Environment()
        env.process(manufractoring_process(env, s))
        env.run()

    objective_function_calc()

# Run the Monte Carlo function
____
कोड संपादित करें और चलाएँ