Linjär programmering är ett kraftfullt verktyg för att optimera produktionsplanering, särskilt när man utvecklar sammanlagda planer. Så här kan det användas:
1. Förstå aggregerad planering:
* Aggregerad planering fokuserar på totalt Produktionsnivåer snarare än individuella produktinformation. Det syftar till att bestämma den optimala produktionshastigheten, arbetskraftsnivåerna, lagernivåerna och kapacitetsutnyttjandet under en medellång sikt horisont (t.ex. 6-18 månader).
* Målet är att balansera efterfrågan med utbudet samtidigt som kostnaderna minimeras.
* Typiska beslut innebär hur mycket man ska producera varje period, hur många arbetare som ska anställa/eld, om de ska använda övertid, om man ska underleverantör och hur mycket lager som ska inneha.
2. Definiera komponenterna i en linjär programmeringsmodell för aggregerad planering:
* Beslutsvariabler: Dessa är de variabler som modellen kommer att optimera. Exempel inkluderar:
* `P_t`:produktionskvantitet i period` t`
* `I_t`:lagernivå i slutet av perioden` t`
* `H_t`:Antal arbetare som anlitats i period` T`
* `F_t`:Antal arbetare som skjutits under perioden` T`
* `OT_T`:Övertidstimmar som används i period` T`
* `S_t`:Antal enheter underleverantörer i period` t`
* Målfunktion: Detta är det matematiska uttrycket som vi vill minimera (vanligtvis kostar) eller maximera (vanligtvis vinst). En gemensam målfunktion för den sammanlagda planeringen syftar till att minimera den totala kostnaden:
`` `
Minimera:∑ (cost_produktion * p_t + cost_inventory * i_t + cost_hiring * h_t + cost_firing * f_t + cost_overtime * ot_t + cost_subcontracting * s_t)
`` `
* `Cost_produktion`,` cost_inventory`, `cost_hiring`, etc., är enhetskostnaderna förknippade med varje beslutsvariabel.
* Begränsningar: Dessa är begränsningarna eller begränsningarna för beslutsvariablerna. Exempel inkluderar:
* Efterfrågan begränsning: Säkerställer att efterfrågan uppfylls varje period.
`` `
P_t + i_ (t-1) + s_t =d_t + i_t för alla t
`` `
där `d_t` är efterfrågan i period` t`. Denna ekvation säger att den tillgängliga leveransen (produktion + början av inventering + underleverantörer) måste motsvara efterfrågan plus den önskade slutliga inventeringen.
* Arbetskraftsbegränsning: Relaterar arbetskraftsnivåer till produktionskapacitet.
`` `
P_t <=capacity_per_worker * w_t + overtime_capacity * ot_t för alla t
W_t =w_ (t -1) + h_t - f_t för alla t
`` `
Där `w_t` är antalet arbetare i period` t`, `capacity_per_worker` är produktionskapaciteten per arbetare, och` övertid_capacitet 'är den maximala övertidskapaciteten.
* Inventarbegränsning: Begränsar mängden lager som kan hållas.
`` `
I_t <=max_inventory_level för alla t
`` `
* Kapacitetsbegränsningar: Begränsa mängden produktion, övertid eller underleverantör.
`` `
P_t <=max_produktion_capacity för alla t
OT_T <=max_overtime_hours för alla t
S_t <=max_subcontracting_units för alla t
`` `
* icke-negativitetsbegränsningar: Se till att beslutsvariabler inte är negativa.
`` `
P_t, i_t, h_t, f_t, ot_t, s_t, w_t> =0 för alla t
`` `
3. Implementeringssteg:
1. Datainsamling: Samla historiska efterfrågan på data, produktionskostnader, lagerhållningskostnader, anställning/skjutkostnader, övertidskostnader, underleverantörskostnader, arbetskraftskapacitet och andra relevanta parametrar. Exakta data är avgörande för att modellen ska ge meningsfulla resultat.
2. Modellformulering: Definiera beslutsvariabler, objektivfunktion och begränsningar baserade på de specifika egenskaperna för din produktionsmiljö. Exemplen ovan är utgångspunkter; Du kan behöva lägga till eller ändra begränsningar för att återspegla din specifika situation.
3. Programvaruimplementering: Använd en linjär programmeringslösare för att hitta den optimala lösningen. Populära alternativ inkluderar:
* kalkylblad Solvers: Microsoft Excel Solver, Google Sheets Solver. Bra för mindre, enklare problem.
* dedikerad optimeringsprogramvara: Gurobi, cplex, ampl, lingo. Mer kraftfull och effektiv för större och mer komplexa problem.
* pythonbibliotek: Scipy (med `scipy.optimize.linprog`), massa, pyomo. Ge flexibilitet och integration med andra dataanalysverktyg.
4. Modellvalidering och känslighetsanalys:
* Validering: Testa modellens resultat mot historiska data eller kända scenarier för att säkerställa att de uppträder som förväntat.
* Känslighetsanalys: Analysera hur den optimala lösningen förändras när nyckelparametrar (t.ex. efterfrågan, kostnader) varierar. Detta hjälper dig att förstå modellens robusthet och identifiera kritiska faktorer.
5. Implementering och övervakning: Implementera den sammanlagda planen som genereras av den linjära programmeringsmodellen och övervaka dess prestanda. Var beredd att justera planen baserat på förändrade förhållanden.
Exempelsscenario (förenklad):
Låt oss säga att ett företag producerar en enda typ av produkt. De vill skapa en sammanlagd plan för de kommande tre månaderna.
* Beslutsvariabler: `P_t` (produktion),` i_t` (inventering), `h_t` (anställer),` f_t` (bränder), för t =1, 2, 3.
* Målfunktion:
`Minimera:10*p_1 + 10*p_2 + 10*p_3 + 2*i_1 + 2*i_2 + 2*i_3 + 500*h_1 + 500*h_2 + 500*h_3 + 300*f_1 + 300*f_2 + 300*f_3`
* Begränsningar:
* efterfrågan:
* `P_1 + i_0 =d_1 + i_1` (t.ex.` p_1 + 0 =1000 + i_1`) där d_1 =1000, i_0 =0
* `P_2 + i_1 =d_2 + i_2` (t.ex.` p_2 + i_1 =1200 + i_2`) där d_2 =1200
* `P_3 + i_2 =d_3 + i_3` (t.ex.` p_3 + i_2 =800 + i_3`) där d_3 =800
* arbetskraft: (Förenklat exempel:Anta ingen initial arbetskraft, och varje arbetare kan producera 50 enheter per månad)
* `P_1 <=50 * (h_1)`
* `P_2 <=50 * (h_1 + h_2)`
* `P_3 <=50 * (h_1 + h_2 + h_3)`
* anställning/skjutbalans: Den här modellen tillåter inte att skjutarbetare anlitade denna period. Du kan lägga till en begränsning `h_1> =f_2` om du ville avfyra några arbetare som anlitade föregående period.
* icke-negativitet: Alla variabler> =0.
Lösaren skulle sedan bestämma de optimala värdena för P1, P2, P3, I1, I2, I3, H1, H2 och H3 som minimerar den totala kostnaden medan de uppfyller efterfrågan och arbetskraftsbegränsningarna.
Fördelar med att använda linjär programmering för sammanlagd planering:
* Optimalitet: Ger en optimal lösning (inom modellens begränsningar) för att minimera kostnaderna eller maximera vinsten.
* hanterar komplexitet: Kan hantera flera faktorer och begränsningar samtidigt, vilket gör det lämpligt för komplexa produktionsmiljöer.
* Känslighetsanalys: Låter dig undersöka effekterna av förändrade förhållanden på den optimala planen.
* "What-if" -analys: Underlättar "vad-om" -scenarier genom att låta dig ändra parametrar och begränsningar för att se hur planen förändras.
* Objektivitet: Ger en datadriven, objektiv strategi för beslutsfattande.
Nackdelar:
* Modellkomplexitet: Att bygga en korrekt och representativ linjär programmeringsmodell kan vara komplex och tidskrävande.
* Datakrav: Kräver betydande mängder exakta data, som kanske inte alltid är tillgängliga.
* Linearitetsantagande: Förutsätter linjära förhållanden mellan variabler, som kanske inte alltid är realistiska.
* statisk plan: Den ursprungliga planen är statisk och måste återföras när betydande förändringar inträffar (t.ex. en plötslig spik i efterfrågan). Rullande horisontplanering kan hjälpa till att mildra detta.
* Fokus på kostnad: Det primära fokuset är ofta på kostnadsminimering. Andra viktiga faktorer, såsom kundtjänstnivåer, kan behöva integreras som begränsningar eller övervägas separat.
Slutsats:
Linjär programmering är ett värdefullt verktyg för att utveckla sammanlagda produktionsplaner. Genom att noggrant definiera beslutsvariablerna, objektivfunktionen och begränsningarna kan du använda linjär programmering för att hitta en optimal plan som balanserar efterfrågan med utbudet samtidigt som kostnaderna minimeras. Det är emellertid viktigt att vara medveten om begränsningarna i linjär programmering och att överväga andra faktorer utöver kostnadsoptimering. Kom ihåg att validera modellen och utföra känslighetsanalys för att säkerställa att planen är robust och anpassningsbar till förändrade förhållanden.
