Duplicate from GowriHari/OptimizationJSSP

.gitattributes

@@ -0,0 +1,34 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

GA.py

@@ -0,0 +1,299 @@
+# importing required modules
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import chart_studio.plotly as py
+import plotly.figure_factory as ff
+import datetime
+from datetime import timedelta
+import time
+import copy
+import openpyxl as xl
+import json
+
+'''Defining Functions for GA Algorithm'''
+def input_file(input):
+    data = data_excel_json(input)
+    op,img,schedule_df = job_schedule(data_dict=data)
+    return op,img,schedule_df
+
+def data_excel_json(excel_sheet):
+    """ convert excel into json """
+    data_excel = xl.load_workbook(excel_sheet)
+    data = {}
+    sheet_name = data_excel.sheetnames
+    for sheet in sheet_name:
+        wb_sheet = data_excel[sheet]
+        cell_values = wb_sheet.values
+        df =  pd.DataFrame(cell_values, columns=next(cell_values))
+        df.iloc[:, 0] = df.iloc[:, 0].apply(lambda x : x.strip())
+        df.index = df.iloc[:, 0]
+        df.drop(columns = df.columns[0], inplace=True)
+        data[sheet] = df.T.to_dict()
+    #print("function - data_excel_json: ", data)
+    return data
+
+def json_to_df(json_data):
+    """ convert json into excel """
+    dict_data = {}
+    for key in json_data.keys():
+        dict_data[key] = pd.DataFrame(json_data.get(key)).T
+    #print("function - json_to_df: ", dict_data)
+    return dict_data
+
+def generate_initial_population(population_size, num_gene):
+
+    """ generate initial population for Genetic Algorithm """
+
+    best_list, best_obj = [], []
+    population_list = []
+    makespan_record = []
+    for i in range(population_size):
+        nxm_random_num = list(np.random.permutation(num_gene)) # generate a random permutation of 0 to num_job*num_mc-1
+        population_list.append(nxm_random_num) # add to the population_list
+        for j in range(num_gene):
+            population_list[i][j] = population_list[i][j] % num_job # convert to job number format, every job appears m times
+    #print("function - generate_initial_population: ", population_list)
+
+    return population_list
+
+
+
+def job_schedule(data_dict, population_size = 30, crossover_rate = 0.8, mutation_rate = 0.2, mutation_selection_rate = 0.2, num_iteration = 3000):
+
+    """ initialize genetic algorithm parameters and read data """
+    data_json  = json_to_df(data_dict)
+    #print(data_json)
+    machine_sequence_tmp = data_json['Machines Sequence']
+    process_time_tmp = data_json['Processing Time']
+#     print("Machine_sequence_tmp: ",machine_sequence_tmp)
+#     print("Processing_time_tmp: ",process_time_tmp)
+    
+    df_shape = process_time_tmp.shape
+    num_machines = df_shape[1] # number of machines
+    num_job = df_shape[0] # number of jobs
+    num_gene = num_machines * num_job # number of genes in a chromosome
+    num_mutation_jobs = round(num_gene * mutation_selection_rate)
+
+    process_time = [list(map(int, process_time_tmp.iloc[i])) for i in range(num_job)]
+    machine_sequence = [list(map(int, machine_sequence_tmp.iloc[i])) for i in range(num_job)]
+    
+    #start_time = time.time()
+
+    Tbest = 999999999999999
+
+    best_list, best_obj = [], []
+    population_list = []
+    makespan_record = []
+
+    for i in range(population_size):
+        nxm_random_num = list(np.random.permutation(num_gene)) # generate a random permutation of 0 to num_job*num_mc-1
+        population_list.append(nxm_random_num) # add to the population_list
+        for j in range(num_gene):
+            population_list[i][j] = population_list[i][j] % num_job # convert to job number format, every job appears m times
+    #population_list = generate_initial_population(population_size=population_size, num_gene=num_gene)
+
+    for iteration in range(num_iteration):
+        Tbest_now = 99999999999
+
+        """ Two Point Cross-Over """
+        parent_list = copy.deepcopy(population_list)
+        offspring_list = copy.deepcopy(population_list) # generate a random sequence to select the parent chromosome to crossover
+        pop_random_size = list(np.random.permutation(population_size))
+
+        for size in range(int(population_size/2)):
+            crossover_prob = np.random.rand()
+            if crossover_rate >= crossover_prob:
+                parent_1 = population_list[pop_random_size[2*size]][:]
+                parent_2 = population_list[pop_random_size[2*size+1]][:]
+
+                child_1 = parent_1[:]
+                child_2 = parent_2[:]
+                cutpoint = list(np.random.choice(num_gene, 2, replace=False))
+                cutpoint.sort()
+
+                child_1[cutpoint[0]:cutpoint[1]] = parent_2[cutpoint[0]:cutpoint[1]]
+                child_2[cutpoint[0]:cutpoint[1]] = parent_1[cutpoint[0]:cutpoint[1]]
+                offspring_list[pop_random_size[2*size]] = child_1[:]
+                offspring_list[pop_random_size[2*size+1]] = child_2[:]
+
+
+        for pop in range(population_size):
+
+            """ Repairment """
+            job_count = {}
+            larger, less = [], [] # 'larger' record jobs appear in the chromosome more than pop times, and 'less' records less than pop times.
+            for job in range(num_job):
+                if job in offspring_list[pop]:
+                    count = offspring_list[pop].count(job)
+                    pos = offspring_list[pop].index(job)
+                    job_count[job] = [count, pos] # store the above two values to the job_count dictionary
+                else:
+                    count = 0
+                    job_count[job] = [count, 0]
+
+                if count > num_machines:
+                    larger.append(job)
+                elif count < num_machines:
+                    less.append(job)
+                    
+            for large in range(len(larger)):
+                change_job = larger[large]
+                while job_count[change_job][0] > num_machines:
+                    for les in range(len(less)):
+                        if job_count[less[les]][0] < num_machines:                    
+                            offspring_list[pop][job_count[change_job][1]] = less[les]
+                            job_count[change_job][1] = offspring_list[pop].index(change_job)
+                            job_count[change_job][0] = job_count[change_job][0]-1
+                            job_count[less[les]][0] = job_count[less[les]][0]+1                    
+                        if job_count[change_job][0] == num_machines:
+                            break     
+    
+
+        
+        for off_spring in range(len(offspring_list)):
+
+            """ Mutations """
+            mutation_prob = np.random.rand()
+            if mutation_rate >= mutation_prob:
+                m_change = list(np.random.choice(num_gene, num_mutation_jobs, replace=False)) # chooses the position to mutation
+                t_value_last = offspring_list[off_spring][m_change[0]] # save the value which is on the first mutation position
+                for i in range(num_mutation_jobs-1):
+                    offspring_list[off_spring][m_change[i]] = offspring_list[off_spring][m_change[i+1]] # displacement
+                # move the value of the first mutation position to the last mutation position
+                offspring_list[off_spring][m_change[num_mutation_jobs-1]] = t_value_last 
+
+
+
+        """ fitness value (calculate makespan) """
+        total_chromosome = copy.deepcopy(parent_list) + copy.deepcopy(offspring_list) # parent and offspring chromosomes combination
+        chrom_fitness, chrom_fit = [], []
+        total_fitness = 0
+        for pop_size in range(population_size*2):
+            j_keys = [j for j in range(num_job)]
+            key_count = {key:0 for key in j_keys}
+            j_count = {key:0 for key in j_keys}
+            m_keys = [j+1 for j in range(num_machines)]
+            m_count = {key:0 for key in m_keys}
+            
+            for i in total_chromosome[pop_size]:
+                gen_t = int(process_time[i][key_count[i]])
+                gen_m = int(machine_sequence[i][key_count[i]])
+                j_count[i] = j_count[i] + gen_t
+                m_count[gen_m] = m_count[gen_m] + gen_t
+                
+                if m_count[gen_m] < j_count[i]:
+                    m_count[gen_m] = j_count[i]
+                elif m_count[gen_m] > j_count[i]:
+                    j_count[i] = m_count[gen_m]
+                
+                key_count[i] = key_count[i] + 1
+        
+            makespan = max(j_count.values())
+            chrom_fitness.append(1/makespan)
+            chrom_fit.append(makespan)
+            total_fitness = total_fitness + chrom_fitness[pop_size]
+        
+
+        """ Selection (roulette wheel approach) """
+        pk, qk = [], []
+        
+        for size in range(population_size * 2):
+            pk.append(chrom_fitness[size] / total_fitness)
+        for size in range(population_size * 2):
+            cumulative = 0
+
+            for j in range(0, size+1):
+                cumulative = cumulative + pk[j]
+            qk.append(cumulative)
+        
+        selection_rand = [np.random.rand() for i in range(population_size)]
+        
+        for pop_size in range(population_size):
+            if selection_rand[pop_size] <= qk[0]:
+                population_list[pop_size] = copy.deepcopy(total_chromosome[0])
+            else:
+                for j in range(0, population_size * 2-1):
+                    if selection_rand[pop_size] > qk[j] and selection_rand[pop_size] <= qk[j+1]:
+                        population_list[pop_size] = copy.deepcopy(total_chromosome[j+1])
+                        break
+
+
+        """ comparison """
+        for pop_size in range(population_size * 2):
+            if chrom_fit[pop_size] < Tbest_now:
+                Tbest_now = chrom_fit[pop_size]
+                sequence_now = copy.deepcopy(total_chromosome[pop_size])
+        if Tbest_now <= Tbest:
+            Tbest = Tbest_now
+            sequence_best = copy.deepcopy(sequence_now)
+            
+        makespan_record.append(Tbest)
+
+    """ Results - Makespan """
+
+    print("optimal sequence", sequence_best)
+    print("optimal value:%f"%Tbest)
+    print("\n")
+    #print('the elapsed time:%s'% (time.time() - start_time))
+    op = "Optimal Schedule Length :"+str(Tbest)
+    #%matplotlib inline
+    plt.plot([i for i in range(len(makespan_record))],makespan_record,'b')
+    plt.ylabel('makespan', fontsize=15)
+    plt.xlabel('generation', fontsize=15)
+    plt.show()
+
+
+    """ plot gantt chart """
+
+    m_keys = [j+1 for j in range(num_machines)]
+    j_keys = [j for j in range(num_job)]
+    key_count = {key:0 for key in j_keys}
+    j_count = {key:0 for key in j_keys}
+    m_count = {key:0 for key in m_keys}
+    j_record = {}
+    for i in sequence_best:
+        gen_t = int(process_time[i][key_count[i]])
+        gen_m = int(machine_sequence[i][key_count[i]])
+        j_count[i] = j_count[i] + gen_t
+        m_count[gen_m] = m_count[gen_m] + gen_t
+
+        if m_count[gen_m] < j_count[i]:
+            m_count[gen_m] = j_count[i]
+        elif m_count[gen_m] > j_count[i]:
+            j_count[i] = m_count[gen_m]
+
+        start_time = str(datetime.timedelta(seconds = j_count[i] - process_time[i][key_count[i]])) # convert seconds to hours, minutes and seconds
+        end_time = str(datetime.timedelta(seconds = j_count[i]))
+
+        j_record[(i, gen_m)] = [start_time, end_time]
+
+        key_count[i] = key_count[i] + 1
+
+
+    df = []
+    for m in m_keys:
+        for j in j_keys:
+            df.append(dict(Task='Machine %s'%(m), Start='2020-02-01 %s'%(str(j_record[(j,m)][0])), \
+                            Finish='2020-02-01 %s'%(str(j_record[(j,m)][1])),Resource='Job %s'%(j+1)))
+
+    df_data = pd.DataFrame(df)
+    df_ = pd.DataFrame(df)
+    df_.Start = pd.to_datetime(df_['Start'])
+    df_.Finish = pd.to_datetime(df_['Finish'])
+    start = df_.Start.min()
+    end = df_.Finish.max()
+
+    df_.Start = df_.Start.apply(lambda x: x.strftime('%Y-%m-%dT%H:%M:%S'))
+    df_.Finish = df_.Finish.apply(lambda x: x.strftime('%Y-%m-%dT%H:%M:%S'))
+    data = df_.to_dict('record')
+
+    final_data ={
+        'start':start.strftime('%Y-%m-%dT%H:%M:%S'),
+        'end':end.strftime('%Y-%m-%dT%H:%M:%S'),
+        'data':data}
+        
+    fig = ff.create_gantt(df, index_col='Resource', show_colorbar=True, group_tasks=True, showgrid_x=True, title='Job shop Schedule')
+    
+    #iplot(fig, filename='GA_job_shop_scheduling')
+    return op, fig, df_data

MIP.py

@@ -0,0 +1,133 @@
+# importing required modules
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import pandas as pd
+import chart_studio.plotly as py
+import plotly.figure_factory as ff
+import datetime
+from datetime import timedelta
+import time
+import copy
+
+#importing PuLP solver
+import pulp
+from itertools import product
+
+def gantt_for_MIP(df,method):
+    title_chart = 'Job shop Schedule - using '+ method
+    fig = ff.create_gantt(df, index_col='Resource', show_colorbar=True, group_tasks=True, showgrid_x=True, title=title_chart)
+    return fig
+
+
+def MIP_fn(input_file):
+    xls = pd.ExcelFile(input_file)
+    df1 = pd.read_excel(xls, 'Machines Sequence',index_col = 0)
+    df2 = pd.read_excel(xls, 'Processing Time',index_col = 0)
+
+    times =[]
+    machines = []
+
+
+    for ind in df1.index:
+        list_m = []
+        list_t = []
+        for col in df1:
+            list_m.append(df1[col][ind]-1) # for MIP formulation
+            list_t.append(df2[col][ind])
+        times.append(list_t)
+        machines.append(list_m)
+
+
+    pt = df2.values
+    mo = df1.values-1 # for the numbering the machines from 0 to 9
+
+    m=n=len(pt[0])
+    print("The number of machines and jobs in the given input data is - ",m)
+
+    #Max time possible for all the jobs - summation of all the process time
+    M = sum(times[i][j] for i in range(n) for j in range(m))
+
+    model = pulp.LpProblem("MIN_makespan", pulp.LpMinimize)
+
+    dv = pulp.LpVariable.dicts("start_time",
+                                        ((i, j) for i in range(m) for j in range(n)),
+                                        lowBound=0,
+                                        cat='Continuous')
+    #print(dv)
+    b =  pulp.LpVariable.dicts("binary_var",
+                                        ((j, k, i) for i in range(m) for k in range(n) for j in range(n)),
+                                        lowBound=0,
+                                        cat='Binary')
+    # print(b)
+    Cmax = pulp.LpVariable('Cmax',lowBound = 0, cat='Continuous')
+
+
+    # (1) operation sequence inside a job
+    model += Cmax
+    for j in range(m):
+        for i in range(n-1):
+            I = mo[j,i]
+            K = mo[j,i+1]
+            J = j
+
+            model += (dv[J,K] - dv[J,I]) >= pt[J][list(mo[J]).index(I)]
+    #         print((dv[J,K] - dv[J,I]) >= pt[J][list(mo[J]).index(I)])
+
+    # (2) the max start time
+    for j in range(m):
+        for i in range(n):
+
+            I = mo[j,i]
+            J = j
+            model += (Cmax - dv[J,I]) >= pt[J][list(mo[J]).index(I)]
+            #print((Cmax - dv[J,I]) >= pt[J][list(mo[J]).index(I)])
+
+    # (3) no overlap for operations assigned to same machine
+    for (j, k) in product(range(n), range(n)):
+        if k != j:
+            for i in range(m):
+                model += dv[j,i] - dv[k,i] + M*b[j,k,i] >= pt[k][list(mo[k]).index(i)]
+                model += -dv[j,i] + dv[k,i] - M*b[j,k,i] >= pt[j][list(mo[j]).index(i)] - M
+
+    start_time = time.time()
+    model.solve(pulp.PULP_CBC_CMD(timeLimit=200))
+    print("Solution status : ",pulp.LpStatus[model.status])
+
+    # for var in dv:
+    #     var_value = dv[var].varValue
+    #     print( var[0],'-',var[1] ,var_value)
+
+    tota_time = pulp.value(model.objective)
+    print ('Optimal time:',tota_time)
+    print('Solver processing time:%s'% (time.time() - start_time))
+    op = "Optimal Schedule Length :"+ str(tota_time)
+    
+    m_keys=[j for j in range(m)]
+    j_keys=[j for j in range(n)]
+    key_count={key:0 for key in j_keys}
+    j_count={key:0 for key in j_keys}
+    m_count={key:0 for key in m_keys}
+    j_record={}
+
+    for var in dv:
+        var_value = dv[var].varValue
+        
+        start_time=str(datetime.timedelta(seconds=var_value)) # convert seconds to hours, minutes and seconds
+        end_time=str(datetime.timedelta(seconds=var_value+pt[var[1]][list(mo[var[1]]).index(var[0])]))
+            
+        j_record[(var[1],var[0])]=[start_time,end_time]
+        
+        key_count[i]=key_count[i]+1
+            
+
+    df=[]
+    for m in m_keys:
+        for j in j_keys:
+            df.append(dict(Task='Machine %s'%(m), Start='2020-02-01 %s'%(str(j_record[(j,m)][0])), Finish='2020-02-01 %s'%(str(j_record[(j,m)][1])),Resource='Job %s'%(j)))
+        
+    method = 'PuLP - CBC Solver'
+    df_data = pd.DataFrame(df)
+
+    return op,gantt_for_MIP(df,method),df_data
+

OR_tools.py

@@ -0,0 +1,148 @@
+# importing required modules
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import pandas as pd
+import chart_studio.plotly as py
+import plotly.figure_factory as ff
+import datetime
+from datetime import timedelta
+import time
+import copy
+
+#importing OR-tools solver
+import collections
+from ortools.sat.python import cp_model
+
+def gantt_for_OR(df,method):
+    title_chart = 'Job shop Schedule - using '+ method
+    fig = ff.create_gantt(df, index_col='Resource', show_colorbar=True, group_tasks=True, showgrid_x=True, title=title_chart)
+    return fig
+
+def or_fn(input_file):
+    xls = pd.ExcelFile(input_file)
+    df1 = pd.read_excel(xls, 'Machines Sequence',index_col = 0)
+    df2 = pd.read_excel(xls, 'Processing Time',index_col = 0)
+    
+    jobs_data =[]
+
+    for ind in df1.index:
+        lists = []
+        for col in df1:
+            lists.append((df1[col][ind],df2[col][ind]))
+        jobs_data.append(lists)
+
+    model = cp_model.CpModel()
+    machines_count = 1 + max(task[0] for job in jobs_data for task in job)
+    all_machines = range(machines_count)
+    # Computes horizon dynamically as the sum of all durations.
+    horizon = sum(task[1] for job in jobs_data for task in job)
+
+    # Named tuple to store information about created variables.
+    task_type = collections.namedtuple('task_type', 'start end interval')
+    # Named tuple to manipulate solution information.
+    assigned_task_type = collections.namedtuple('assigned_task_type',
+                                                'start job index duration')
+
+    # Creates job intervals and add to the corresponding machine lists.
+    all_tasks = {}
+    machine_to_intervals = collections.defaultdict(list)
+
+    for job_id, job in enumerate(jobs_data):
+        for task_id, task in enumerate(job):
+            machine = task[0]
+            duration = task[1]
+            suffix = '_%i_%i' % (job_id, task_id)
+            start_var = model.NewIntVar(0, horizon, 'start' + suffix)
+            end_var = model.NewIntVar(0, horizon, 'end' + suffix)
+            interval_var = model.NewIntervalVar(start_var, duration, end_var,
+                                                'interval' + suffix)
+            all_tasks[job_id, task_id] = task_type(start=start_var,
+                                                end=end_var,
+                                                interval=interval_var)
+            machine_to_intervals[machine].append(interval_var)
+            
+    # Create and add disjunctive constraints.
+    for machine in all_machines:
+        model.AddNoOverlap(machine_to_intervals[machine])
+
+    # Precedences inside a job.
+    for job_id, job in enumerate(jobs_data):
+        for task_id in range(len(job) - 1):
+            model.Add(all_tasks[job_id, task_id +
+                                1].start >= all_tasks[job_id, task_id].end)
+
+    # Makespan objective.
+    obj_var = model.NewIntVar(0, horizon, 'makespan')
+    model.AddMaxEquality(obj_var, [
+        all_tasks[job_id, len(job) - 1].end
+        for job_id, job in enumerate(jobs_data)
+    ])
+    model.Minimize(obj_var)
+
+    start_time = time.time()
+
+    solver = cp_model.CpSolver()
+    status = solver.Solve(model)
+
+    print("--- %s seconds ---" % (time.time() - start_time))
+
+    if status == cp_model.OPTIMAL or status == cp_model.FEASIBLE:
+        print('Solution:')
+        # Create one list of assigned tasks per machine.
+        assigned_jobs = collections.defaultdict(list)
+        for job_id, job in enumerate(jobs_data):
+            for task_id, task in enumerate(job):
+                machine = task[0]
+                assigned_jobs[machine].append(
+                    assigned_task_type(start=solver.Value(
+                        all_tasks[job_id, task_id].start),
+                                    job=job_id,
+                                    index=task_id,
+                                    duration=task[1]))
+
+        # Create per machine output lines.
+        output = ''
+        for machine in all_machines:
+            # Sort by starting time.
+            assigned_jobs[machine].sort()
+            sol_line_tasks = 'Machine ' + str(machine) + ': '
+            sol_line = '           '
+
+            for assigned_task in assigned_jobs[machine]:
+                name = 'job_%i_task_%i' % (assigned_task.job,
+                                        assigned_task.index)
+                # Add spaces to output to align columns.
+                sol_line_tasks += '%-15s' % name
+
+                start = assigned_task.start
+                duration = assigned_task.duration
+                sol_tmp = '[%i,%i]' % (start, start + duration)
+                # Add spaces to output to align columns.
+                sol_line += '%-15s' % sol_tmp
+
+            sol_line += '\n'
+            sol_line_tasks += '\n'
+            output += sol_line_tasks
+            output += sol_line
+
+        # Finally print the solution found.
+        print(f'Optimal Schedule Length: {solver.ObjectiveValue()}')
+        op = "Optimal Schedule Length : "+ str(solver.ObjectiveValue())
+        #print(output)
+    else:
+        print('No solution found.')
+        op = "No solution found."
+    #Solution df:
+    df = []
+    for machine in all_machines:
+        for task in assigned_jobs[machine]:
+            df.append(dict(Task='Machine %s'%(machine), Start='2020-02-01 %s'%(str(timedelta(seconds=int(task[0])))), \
+                                Finish='2020-02-01 %s'%(str(timedelta(seconds=int(task[0]+task[3])))),Resource='Job %s'%(task[1])))
+
+    method = 'OR Tools'
+    fig = gantt_for_OR(df,method)
+    fig.show()
+    df_data = pd.DataFrame(df)
+    
+    return op,gantt_for_OR(df,method),df_data   

README.md

@@ -0,0 +1,14 @@
+---
+title: OptimizationJSSP
+emoji: 🌍
+colorFrom: pink
+colorTo: pink
+sdk: gradio
+sdk_version: 3.29.0
+app_file: app.py
+pinned: false
+license: mit
+duplicated_from: GowriHari/OptimizationJSSP
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,55 @@
+# importing required modules
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import datetime
+from datetime import timedelta
+import time
+import copy
+import openpyxl as xl
+import json
+import gradio as gr
+import io
+from PIL import Image
+
+#importing 3 functions:
+import GA
+import OR_tools as ort
+import MIP
+
+def plotly_fig2array(fig):
+    #convert Plotly fig to  an array
+    fig_bytes = fig.to_image(format="png")
+    buf = io.BytesIO(fig_bytes)
+    img = Image.open(buf)
+    return np.asarray(img)
+
+def JSSP(method,temp_file):
+    xls = pd.ExcelFile(temp_file.name)
+    print(xls)
+    print("Input File is :",xls)
+    if method == "Genetic Algo":
+      op, fig, df = GA.input_file(xls)
+      
+    elif method == "Python OR":
+      op, fig, df = ort.or_fn(xls)
+        
+    else:
+      op, fig, df = MIP.MIP_fn(xls)
+    
+    img = plotly_fig2array(fig)
+    # data = pd.DataFrame(df)
+    df.to_excel("op_data.xlsx",index=False)
+    data_op = ["op_data.xlsx"]
+    return op, img,data_op
+
+demo = gr.Interface(JSSP,
+                             inputs=[gr.Radio(["Genetic Algo", "Python OR", "MIP solution"], label="Solution Method", info="Choose one method to solve ypur Job Shop problem."),gr.File(label = 'Input File')],
+                             examples =[["Python OR","Demo_data.xlsx"]],
+                             outputs = ["text","image",gr.File(label='Output File')],
+                             title = "Job Shop Scheduling Problem",
+                             description = "Upload an excel file containing Machine Sequnce and Processing Time for a n x m problem to optimize makespan for manufacturing or Job schedule. Choose the method you want the problem to be solved before clicking Submit! \n For Demo purpose, use the example data provided BELOW.",
+                             cache_examples = False )
+
+
+demo.queue().launch(debug=True,show_error=True)

requirements.txt

@@ -0,0 +1,28 @@
+chart-studio==1.1.0
+convertdate==2.4.0
+gradio==3.32.0
+gradio_client==0.2.5
+jsonpickle==3.0.1
+jsonschema==4.3.3
+matplotlib==3.7.1
+matplotlib-inline==0.1.6
+matplotlib-venn==0.11.9
+more-itertools==9.1.0
+numpy==1.22.4
+openpyxl==3.0.10
+orjson==3.8.12
+ortools==9.6.2534
+pandas==1.5.3
+pandas-datareader==0.10.0
+pandas-gbq==0.17.9
+plotly==5.13.1
+PuLP==2.7.0
+python-dateutil==2.8.2
+python-utils==3.5.2
+scikit-image==0.19.3
+scikit-learn==1.2.2
+scipy==1.10.1
+seaborn==0.12.2
+sklearn-pandas==2.2.0
+kaleido
+pillow