Add files via upload

Author: JingweiToo

FS/__init__.py

@@ -0,0 +1 @@
+#

FS/de.py

@@ -0,0 +1,146 @@
+#[1997]-"Differential evolution - A simple and efficient heuristic for global optimization over continuous spaces"
+
+import numpy as np
+from numpy.random import rand
+from FS.functionHO import Fun
+
+
+def init_position(lb, ub, N, dim):
+    X = np.zeros([N, dim], dtype='float')
+    for i in range(N):
+        for d in range(dim):
+            X[i,d] = lb[0,d] + (ub[0,d] - lb[0,d]) * rand()        
+    
+    return X
+
+
+def binary_conversion(X, thres, N, dim):
+    Xbin = np.zeros([N, dim], dtype='int')
+    for i in range(N):
+        for d in range(dim):
+            if X[i,d] > thres:
+                Xbin[i,d] = 1
+            else:
+                Xbin[i,d] = 0
+    
+    return Xbin
+
+
+def boundary(x, lb, ub):
+    if x < lb:
+        x = lb
+    if x > ub:
+        x = ub
+    
+    return x
+    
+
+def jfs(xtrain, ytrain, opts):
+    # Parameters
+    ub    = 1
+    lb    = 0
+    thres = 0.5
+    CR    = 0.9     # crossover rate
+    F     = 0.5     # factor
+    
+    N        = opts['N']
+    max_iter = opts['T']
+    if 'CR' in opts:
+        CR   = opts['CR'] 
+    if 'F' in opts:
+        F    = opts['F']     
+    
+    # Dimension
+    dim = np.size(xtrain, 1)
+    if np.size(lb) == 1:
+        ub = ub * np.ones([1, dim], dtype='int')
+        lb = lb * np.ones([1, dim], dtype='int')
+        
+    # Initialize position & velocity
+    X     = init_position(lb, ub, N, dim)
+    
+    # Binary conversion
+    Xbin  = binary_conversion(X, thres, N, dim)
+    
+    # Fitness at first iteration
+    fit   = np.zeros([N, 1], dtype='float')
+    fitG  = float('inf')
+    for i in range(N):
+        fit[i,0] = Fun(xtrain, ytrain, Xbin[i,:], opts)
+        if fit[i,0] < fitG:
+            Xgb  = X[i,:]
+            fitG = fit[i,0]
+            Gbin = Xbin[i,:]
+    
+    # Pre
+    V     = np.zeros([N, dim], dtype='float')
+    U     = np.zeros([N, dim], dtype='float')
+    curve = np.zeros([1, max_iter], dtype='float') 
+    t     = 0
+    
+    curve[0,t] = fitG
+    print("Generation:", t + 1)
+    print("Best (DE):", curve[0,t])
+    t += 1
+
+    while t < max_iter:     
+        for i in range(N):
+            # Choose r1, r2, r3 randomly, but not equal to i 
+            RN = np.random.permutation(N)
+            for j in range(N):
+                if RN[j] == i:
+                    RN = np.delete(RN, j)
+                    break
+                
+            r1 = RN[0]
+            r2 = RN[1]
+            r3 = RN[2]
+            # mutation (2)
+            for d in range(dim):
+                V[i,d] = X[r1,d] + F * (X[r2,d] - X[r3,d])
+                # Boundary
+                V[i,d] = boundary(V[i,d], lb[0,d], ub[0,d])
+            
+            # Random one dimension from 1 to dim
+            index   = np.random.randint(low = 0, high = dim)
+            # crossover (3-4)
+            for d in range(dim):
+                if rand() <= CR or d == index:
+                    U[i,d] = V[i,d]
+                else:
+                    U[i,d] = X[i,d]
+        
+        # Binary conversion
+        Ubin = binary_conversion(U, thres, N, dim)
+        # Selection
+        for i in range(N):
+            fitU = Fun(xtrain, ytrain, Ubin[i,:], opts)
+            if fitU <= fit[i,0]:
+                X[i,:]   = U[i,:]
+                fit[i,0] = fitU
+            if fitU < fitG:
+                Xgb      = U[i,:]
+                fitG     = fitU
+                Gbin     = Ubin[i,:]
+            
+                
+        # Store result
+        curve[0,t] = fitG
+        print("Generation:", t + 1)
+        print("Best (DE):", curve[0,t])
+        t += 1            
+
+            
+    # Best feature subset
+    pos        = np.asarray(range(0, dim))    
+    sel_index  = pos[Gbin == 1]
+    num_feat   = len(sel_index)
+    # Create dictionary
+    de_data = {'sf': sel_index, 'c': curve, 'nf': num_feat}
+    
+    return de_data  
+
+
+            
+            
+                

FS/functionHO.py

@@ -0,0 +1,58 @@
+import numpy as np
+from sklearn.neighbors import KNeighborsClassifier
+
+
+# error rate
+def error_rate(xtrain, ytrain, x, opts):
+    # parameters
+    k     = opts['k']
+    fold  = opts['fold']
+    xt    = fold['xt']
+    yt    = fold['yt']
+    xv    = fold['xv']
+    yv    = fold['yv']
+    
+    # Number of instances
+    num_train = np.size(xt, 0)
+    num_valid = np.size(xv, 0)
+    # Define selected features
+    xtrain  = xt[:, x == 1]
+    ytrain  = yt.reshape(num_train)  # Solve bug
+    xvalid  = xv[:, x == 1]
+    yvalid  = yv.reshape(num_valid)  # Solve bug   
+    # Training
+    mdl     = KNeighborsClassifier(n_neighbors = k)
+    mdl.fit(xtrain, ytrain)
+    # Prediction
+    pred    = mdl.predict(xvalid)
+    correct = 0
+    for i in range(num_valid):
+        if pred[i] == yvalid[i]:
+            correct += 1
+    
+    accuracy = correct / num_valid
+    error    = 1 - accuracy
+    
+    return error
+
+
+# Error rate & Feature size
+def Fun(xtrain, ytrain, x, opts):
+    # Parameters
+    alpha    = 0.99
+    beta     = 1 - alpha
+    # Original feature size
+    max_feat = len(x)
+    # Number of selected features
+    num_feat = sum(x == 1)
+    # Solve if no feature selected
+    if num_feat == 0:
+        cost  = 1
+    else:
+        # Get error rate
+        error = error_rate(xtrain, ytrain, x, opts)
+        # Objective function
+        cost  = alpha * error + beta * (num_feat / max_feat)
+        
+    return cost
+

FS/ga.py

@@ -0,0 +1,141 @@
+import numpy as np
+from numpy.random import rand
+from FS.functionHO import Fun
+
+
+def init_position(N, dim):
+    X = np.zeros([N, dim], dtype='int')
+    for i in range(N):
+        for d in range(dim):
+            if rand() > 0.5:
+                X[i,d] = 1
+            else:
+                X[i,d] = 0
+    
+    return X
+
+
+def roulette_wheel(prob):
+    num = len(prob)
+    C   = np.cumsum(prob)
+    P   = rand()
+    for i in range(num):
+        if C[i] > P:
+            index = i;
+            break
+    
+    return index
+
+
+def jfs(xtrain, ytrain, opts):
+    # Parameters
+    CR       = 0.8     # crossover rate
+    MR       = 0.01    # mutation rate
+    
+    N        = opts['N']
+    max_iter = opts['T']
+    if 'CR' in opts:
+        CR   = opts['CR'] 
+    if 'MR' in opts: 
+        MR   = opts['MR']  
+ 
+     # Dimension
+    dim   = np.size(xtrain, 1)
+    # Initialize position & velocity
+    X     = init_position(N, dim)
+    
+    # Fitness at first iteration
+    fit   = np.zeros([N, 1], dtype='float')
+    fitG  = float('inf')
+    for i in range(N):
+        fit[i,0] = Fun(xtrain, ytrain, X[i,:], opts)
+        if fit[i,0] < fitG:
+            Xgb  = X[i,:]
+            fitG = fit[i,0]
+    
+    # Pre
+    curve = np.zeros([1, max_iter], dtype='float')
+    t     = 0
+    
+    curve[0,t] = fitG
+    print("Generation:", t + 1)
+    print("Best (GA):", curve[0,t])
+    t += 1
+    
+    while t < max_iter:
+        # Probability
+        inv_fit = 1 / (1 + fit)
+        prob    = inv_fit / np.sum(inv_fit) 
+ 
+        # Number of crossovers
+        Nc = 0
+        for i in range(N):
+            if rand() < CR:
+              Nc += 1
+              
+        x1 = np.zeros([Nc, dim], dtype='int')
+        x2 = np.zeros([Nc, dim], dtype='int')
+        for i in range(Nc):
+            # Parent selection
+            k1      = roulette_wheel(prob)
+            k2      = roulette_wheel(prob)
+            P1      = X[k1,:]
+            P2      = X[k2,:]
+            # Random one dimension from 1 to dim
+            index   = np.random.randint(low = 1, high = dim)
+            # Crossover
+            x1[i,:] = np.concatenate((P1[0:index] , P2[index:]))
+            x2[i,:] = np.concatenate((P2[0:index] , P1[index:]))
+            # Mutation
+            for d in range(dim):
+                if rand() < MR:
+                    x1[i,d] = 1 - x1[i,d]
+                    
+                if rand() < MR:
+                    x2[i,d] = 1 - x2[i,d]
+
+        
+        # Merge two group into one
+        Xnew = np.concatenate((x1 , x2), axis=0)
+        
+        # Fitness
+        Fnew = np.zeros([2 * Nc, 1], dtype='float')
+        for i in range(2 * Nc):
+            Fnew[i,0] = Fun(xtrain, ytrain, Xnew[i,:], opts)
+            if Fnew[i,0] < fitG:
+                Xgb  = Xnew[i,:]
+                fitG = Fnew[i,0]
+                   
+        # Store result
+        curve[0,t] = fitG
+        print("Generation:", t + 1)
+        print("Best (GA):", curve[0,t])
+        t += 1
+        
+        # Elitism 
+        XX  = np.concatenate((X , Xnew), axis=0)
+        FF  = np.concatenate((fit , Fnew), axis=0)
+        # Sort in ascending order
+        ind = np.argsort(FF, axis=0)
+        for i in range(N):
+            X[i,:]   = XX[ind[i,0],:]
+            fit[i,0] = FF[ind[i,0]]
+       
+            
+    # Best feature subset
+    pos        = np.asarray(range(0, dim))    
+    sel_index  = pos[Xgb == 1]
+    num_feat   = len(sel_index)
+    # Create dictionary
+    ga_data = {'sf': sel_index, 'c': curve, 'nf': num_feat}
+    
+    return ga_data 
+            
+            
+                
+        
+        
+        
+    
+    
+