Example #1
0
 def pls_cv(self,ncomp_range=range(1,21),plot=False,verbose=False,
            osc_params=(10,1)):
     # Separating X from Y for PLS
     X=self.df[self.freqs].to_numpy()
     Y=self.df[self.y_name].to_numpy().reshape(-1, 1)
     sample_std=np.std(self.df[self.y_name])
     
     # CV based on measurement day
     if self.cval=="MD":
         cv = LeaveOneGroupOut()
         folds=list(cv.split(X=X,y=Y,groups=self.df[self.date_name]))
     # kfold CV
     elif self.cval=="kfold":
         cv = KFold(n_splits=self.cval_param)
         folds=list(cv.split(X))
     else:
         raise InputError("Invalid CV type!")
     
     # Array for storing CV errors
     cv_RMSE_all=np.zeros([len(folds),len(ncomp_range)])
     i=0
     for train, val in folds:
         # If OSC model specified
         if len(osc_params)==2:
             osc=OSC(nicomp=osc_params[0],ncomp=osc_params[1])
             osc.fit(X[train], Y[train])
             X_train_osc=osc.X_osc
             X_val_osc=osc.transform(X[val])
         j=0
         for ncomp in ncomp_range:
             pls = PLSRegression(n_components=ncomp,scale=False)
             if len(osc_params)==2:
                 pls.fit(X_train_osc, Y[train])
                 cv_RMSE_all[i,j]=metrics.mean_squared_error(
                     Y[val], pls.predict(X_val_osc))**0.5
             else:
                 pls.fit(X[train], Y[train])
                 cv_RMSE_all[i,j]=metrics.mean_squared_error(
                         Y[val], pls.predict(X[val]))**0.5
             j=j+1
         i=i+1
     # Printing and plotting CV results
     cv_RMSE_ncomp=np.mean(cv_RMSE_all,axis=0)
     cv_RPD_ncomp=sample_std/cv_RMSE_ncomp
     if plot:
         fig = plt.figure(figsize=(12,8))
         plt.gca().xaxis.grid(True)
         plt.xticks(ncomp_range)
         plt.ylabel("RPD")
         plt.xlabel("Number of components")
         plt.plot(ncomp_range,cv_RPD_ncomp)
     # Best model
     rpd_best=max(cv_RPD_ncomp)
     ncomp_best=ncomp_range[cv_RMSE_ncomp.argmin()]
     if verbose:
         print("Best RMSE: ",min(cv_RMSE_ncomp))
         print("Best RPD: ",max(cv_RPD_ncomp))
         print("Number of latent components: ",ncomp_range[cv_RMSE_ncomp.argmin()])
     return (ncomp_best,rpd_best)
Example #2
0
 def fssregression_cv(self,inner_cv="kfold",inner_cv_param=5,maxvar=2,verbose=False,
                      osc_params=(10,1)):
     #inner CV can be "kfold" or "none"
     # Separating X from Y for PLS
     X=self.df[self.freqs]
     Y=self.df[self.y_name]
     
     # Create list for selected variables
     best_vars=[]
     reg = FSSRegression(inner_cv,inner_cv_param,maxvar)
     # CV based on measurement day
     if self.cval=="MD":
         cv = LeaveOneGroupOut()
         folds=list(cv.split(X=X,y=Y,groups=self.df[self.date_name]))
     # kfold CV
     elif self.cval=="kfold":
         cv = KFold(n_splits=self.cval_param)
         folds=list(cv.split(X))
     else:
         raise InputError("Invalid CV type!")  
     i=0
     #Array for cv values
     cv_RMSE_all=np.zeros([len(folds)])
     for train,val in folds:
         # If OSC model specified
         if len(osc_params)==2:
             osc=OSC(nicomp=osc_params[0],ncomp=osc_params[1])
             # FSSR needs column names, so it uses pandas, but osc uses numpy arrays
             osc.fit(X.iloc[train].to_numpy(), Y.iloc[train].to_numpy().reshape(-1,1))
             X_train_osc=pd.DataFrame(data=osc.X_osc,columns=self.freqs)
             X_val_osc=pd.DataFrame(data=osc.transform(X.iloc[val].to_numpy()),columns=self.freqs)
             # Fit and predict
             reg.fit(X_train_osc, Y.iloc[train])
             cv_RMSE_all[i]=metrics.mean_squared_error(
                     Y.iloc[val], reg.predict(X_val_osc))**0.5
             best_vars.append(reg.bestvar) 
         else:
             reg.fit(X.iloc[train], Y.iloc[train])
             cv_RMSE_all[i]=metrics.mean_squared_error(
                     Y.iloc[val], reg.predict(X.iloc[val]))**0.5
             best_vars.append(reg.bestvar)        
         i=i+1
     cv_RMSE=np.mean(cv_RMSE_all)
     rpd=np.std(self.df[self.y_name])/cv_RMSE
     if verbose:
         print("RMSE: ",cv_RMSE)
         print("RPD: ",rpd)
         print("Selected freqs: ",best_vars)
         k=0
         for day in self.df[self.date_name].unique():    
             print("Date: {0}, Measurements: {1:.0f}, RMSE: {2:.2f}, selected vars: {3}"
                   .format(
                     np.datetime_as_string(day,unit='D'),
                     sum(self.df[self.date_name]==day),
                         cv_RMSE_all[k],
                         len(best_vars[k])))
             k=k+1
           
     return(rpd)
Example #3
0
def test_handler(addr, tags, stuff, source):
    print(' - Got OSC message')
    room_name = str(stuff[0])
    data = ','.join([str(e) for e in stuff[1:]]) + ' | from %s' % OSC.getUrlStr(source)
    if room_name != '0':
        socketio.emit('my response', {'data': data}, namespace='/test', room=room_name)
    else:
        socketio.emit('my response', {'data': data}, namespace='/test')
Example #4
0
 def __init__(self):
     super(LongWebW, self).__init__()
     self.grid = QGridLayout(self)
     self.osc = OSC()
     self.osc.clear()
     self.view_list = [LongWebView(), LongWebView()] 
     self.view_list[0].setSizePolicy(QSizePolicy.MinimumExpanding,QSizePolicy.Preferred)
     self.view_list[1].setSizePolicy(QSizePolicy.MinimumExpanding,QSizePolicy.Preferred)
     self.onData_list = [[], []] # [[(cur_set, onset),], [(cur_set, onset),]
     self.offData_list = [[], []] # [[(cur_set, offset),], [(cur_set, offset),]
     self.onOff_list = [[], []]
     self.grid.addWidget(self.view_list[0], 0,0,1,1)
     self.grid.addWidget(self.view_list[1], 1,0,1,1)
     self.setMinimumWidth(1200)
     self.setFixedHeight(700)
     self.cur_notes_set = set()
     self.lock = threading.RLock()
     self.idx = 0
     self.auto = False
     self.renewParserT("molihua.abc")
Example #5
0
def acc_intensity_handler(addr, tags, stuff, source):
    data = ','.join([str(e) for e in stuff[1:]]) + ' | from %s' % OSC.getUrlStr(source)
    print data
    socketio.emit('my response', {'data': data}, namespace='/test')
Example #6
0
    def ipls_cv(self,version="basic",nint_list=[8,16,32],ncomp_range=range(1,10),
                inner_cv="kfold",inner_cv_param=5,verbose=True,
                osc_params=(10,1)):
               
        X=self.df[self.freqs]
        Y=self.df[self.y_name]

        # CV based on measurement day
        if self.cval=="MD":
            cv = LeaveOneGroupOut()
            folds=list(cv.split(X=X,y=Y,groups=self.df[self.date_name]))
        # kfold CV
        elif self.cval=="kfold":
            cv = KFold(n_splits=self.cval_param)
            folds=list(cv.split(X))
        else:
            raise InputError("Invalid CV type!") 
            
        #Array for cv values
        cv_RMSE_all=np.zeros([len(folds),len(ncomp_range),len(nint_list)])
        i=0
        for train,val in folds:
            # If OSC model specified
            if len(osc_params)==2:
                osc=OSC(nicomp=osc_params[0],ncomp=osc_params[1])
                # IPLS needs column names, so it uses pandas, but osc uses numpy arrays
                osc.fit(X.iloc[train].to_numpy(), Y.iloc[train].to_numpy().reshape(-1,1))
                X_train_osc=pd.DataFrame(data=osc.X_osc,columns=self.freqs)
                X_val_osc=pd.DataFrame(data=osc.transform(X.iloc[val].to_numpy()),columns=self.freqs)
            j=0
            for ncomp in ncomp_range:
                k=0
                for nint in nint_list:
                    ipls_obj=IntervalPLSRegression(ncomp=ncomp,nint=nint,
                                                       cv_type=inner_cv,cv_param=inner_cv_param)
                    if len(osc_params)==2:
                        ipls_obj.fit(X_train_osc, Y.iloc[train])
                        cv_RMSE_all[i,j,k]=metrics.mean_squared_error(
                                 Y.iloc[val], ipls_obj.predict(X_val_osc))**0.5
                    else:
                        ipls_obj.fit(X.iloc[train], Y.iloc[train])
                        cv_RMSE_all[i,j,k]=metrics.mean_squared_error(
                                 Y.iloc[val], ipls_obj.predict(X.iloc[val]))**0.5
                    k=k+1
                j=j+1
            i=i+1
        cv_RMSE=np.mean(cv_RMSE_all,axis=0)
        RMSE_best=np.amin(cv_RMSE)
        
        rpd_best=np.std(self.df[self.y_name])/RMSE_best
        # Best model
        ncomp_best=ncomp_range[np.where(
                cv_RMSE==RMSE_best)[0][0]]
        nint_best=nint_list[np.where(
                cv_RMSE==RMSE_best)[1][0]]
        if verbose:
            print("Best RMSE: ",RMSE_best)
            print("Best RPD: ",rpd_best)
            print("Number of components:",ncomp_best)
            print("Number of intervals:",nint_best)
        return (ncomp_best,nint_best,rpd_best)
Example #7
0
    def mcw_pls_cv(self,ncomp_range=range(1,21),sig_start=0.1,optimization="grid",
                   plot=False,verbose=True,
                   osc_params=(10,1)):
        # Separating X from Y for PLS
        # Needs to be converted to numpy array from pandas df
        X=self.df[self.freqs].to_numpy()
        # Y need to be converted to numpy array from pandas series and reshaped to (N,1) from (N,)
        Y=self.df[self.y_name].to_numpy().reshape(-1, 1)
        sample_std=np.std(self.df[self.y_name])
        
        # CV based on measurement day
        if self.cval=="MD":
            cv = LeaveOneGroupOut()
            folds=list(cv.split(X=X,y=Y,groups=self.df[self.date_name]))
        # kfold CV
        elif self.cval=="kfold":
            cv = KFold(n_splits=self.cval_param)
            folds=list(cv.split(X))
        else:
            raise InputError("Invalid CV type!")  
        
        if optimization=="grid":
            # Create a search vector from starting values for gridsearch
            sig_list=np.linspace(sig_start/10,sig_start*10,30)

            rpd_best_all=0
            non_improve=0
            
            repeat=True
            while repeat:
                # Array for storing CV errors
                cv_RMSE_all=np.zeros([len(folds),len(ncomp_range),len(sig_list)])
                i=0
                for train,val in folds:
                    # If OSC model specified
                    if len(osc_params)==2:
                        osc=OSC(nicomp=osc_params[0],ncomp=osc_params[1])
                        osc.fit(X[train], Y[train])
                        X_train_osc=osc.X_osc
                        X_val_osc=osc.transform(X[val])
                    j=0
                    for ncomp in ncomp_range:
                        k=0
                        for sig in sig_list:
                            if len(osc_params)==2:
                                pls = mcw_pls_sklearn(n_components=ncomp, max_iter=30, R_initial=None, scale_sigma2=sig)
                                pls.fit(X_train_osc, Y[train])
                                cv_RMSE_all[i,j,k]=metrics.mean_squared_error(
                                        Y[val], pls.predict(X_val_osc))**0.5
                            else:        
                                pls = mcw_pls_sklearn(n_components=ncomp, max_iter=30, R_initial=None, scale_sigma2=sig)
                                pls.fit(X[train], Y[train])
                                cv_RMSE_all[i,j,k]=metrics.mean_squared_error(
                                        Y[val], pls.predict(X[val]))**0.5
                            k=k+1
                        j=j+1
                    i=i+1

                cv_RMSE_ncomp_sigs=np.mean(cv_RMSE_all,axis=0)

                # Best model
                ncomp_best=ncomp_range[np.where(
                        cv_RMSE_ncomp_sigs==np.amin(cv_RMSE_ncomp_sigs))[0][0]]
                sig_best=sig_list[np.where(
                        cv_RMSE_ncomp_sigs==np.amin(cv_RMSE_ncomp_sigs))[1][0]]
                rpd_best=sample_std/np.amin(cv_RMSE_ncomp_sigs)
                if verbose:
                    print("Best RMSE: ",np.amin(cv_RMSE_ncomp_sigs))
                    print("Best RPD: ",rpd_best)
                    print("Number of latent components: ",ncomp_best)
                    print("Best sigma: ",sig_best)
           
                # Check against all time best
                if rpd_best>rpd_best_all:
                    ncomp_best_all = ncomp_best
                    sig_best_all = sig_best
                    rpd_best_all= rpd_best
                else:
                    # Increase counter if there is no improvement
                    non_improve=non_improve+1
                repeat=False
                # Check if best value is in IQ range
                if sig_best<np.quantile(sig_list,0.2) or sig_best>np.quantile(sig_list,0.8):
                    # If not, move the search interval based on the magnitude of the best value
                    scale=math.floor(math.log10(sig_best))-1
                    lower=sig_best-(10**scale)*5
                    upper=sig_best+(10**scale)*5
                    # If best value is at the extreme of the interval expand it by a lot that way
                    if min(sig_list)==sig_best:
                        lower=sig_best/2
                    elif max(sig_list)==sig_best:
                        upper=sig_best*2
                    # Create new search vector
                    sig_list=np.linspace(lower,upper,10)
                    # Repeat evaluation
                    repeat=True
                # Terminate early if no improvements in 10 iterations        
                if non_improve>10:
                    repeat=False
                    print("No improvement, terminate early.")
                if repeat:
                    print("new iteration")
            # Set final values to all time best
            ncomp_best=ncomp_best_all
            sig_best=sig_best_all
            rpd_best=rpd_best_all
        

        elif optimization=="simple":

            # Array for storing CV errors
            sig_list=sig_start
            cv_RMSE_all=np.zeros([len(folds),len(ncomp_range),len(sig_list)])
            
            i=0
            for ncomp in ncomp_range:
                j=0
                for sig in sig_list:
                    pls = mcw_pls_sklearn(n_components=ncomp, max_iter=30, R_initial=None, scale_sigma2=sig)
                    k=0
                    for train,val in folds:
                        pls.fit(X[train], Y[train])
                        cv_RMSE_all[k,i,j]=metrics.mean_squared_error(
                                Y[val], pls.predict(X[val]))**0.5
                        k=k+1
                    j=j+1
                i=i+1
            
            # Printing and plotting CV results
            cv_RMSE_ncomp_sigs=np.mean(cv_RMSE_all,axis=0)
            if plot:
                cv_RPD_ncomp_sigs=sample_std/cv_RMSE_ncomp_sigs
                fig = plt.figure(figsize=(10,5))
                ax = plt.axes(projection="3d")
                # Cartesian indexing (x,y) transposes matrix indexing (i,j)
                x, y = np.meshgrid(list(sig_list),list(ncomp_range))
                z=cv_RPD_ncomp_sigs
                ls = LightSource(270, 45)
                rgb = ls.shade(z, cmap=cm.gist_earth, vert_exag=0.1, blend_mode='soft')
                surf = ax.plot_surface(x, y, z, rstride=1, cstride=1, facecolors=rgb,
                                       linewidth=0, antialiased=False, shade=False)
    
            plt.show()
            # Best model
            ncomp_best=ncomp_range[np.where(
                    cv_RMSE_ncomp_sigs==np.amin(cv_RMSE_ncomp_sigs))[0][0]]
            sig_best=sig_list[np.where(
                    cv_RMSE_ncomp_sigs==np.amin(cv_RMSE_ncomp_sigs))[1][0]]
            rpd_best=sample_std/np.amin(cv_RMSE_ncomp_sigs)
            print("Best RMSE: ",np.amin(cv_RMSE_ncomp_sigs))
            print("Best RPD: ",rpd_best)
            print("Number of latent components: ",ncomp_best)
            print("Best sigma: ",sig_best)
    
        return (ncomp_best,sig_best,rpd_best)
Example #8
0
 def svr_cv(self,gam_start=0.001,
            c_start=100,
            eps_start=0.1,
            optimization="grid",gridscale=5,non_improve_lim=10,verbose=False,
            osc_params=None):
     # Separating X from Y for PLS
     X=self.df[self.freqs].to_numpy()
     Y=self.df[self.y_name].to_numpy().reshape(-1, 1)
     sample_std=np.std(self.df[self.y_name])
     # CV based on measurement day
     if self.cval=="MD":
         cv = LeaveOneGroupOut()
         folds=list(cv.split(X=X,y=Y,groups=self.df[self.date_name]))
     # kfold CV
     elif self.cval=="kfold":
         cv = KFold(n_splits=self.cval_param)
         folds=list(cv.split(X))
     else:
         raise InputError("Invalid CV type!")
     
     if optimization=="none":
         cv_RMSE=np.zeros(len(folds))
         # Only use RBF kernels, also standardize data
         pipe = Pipeline([('scaler', StandardScaler()),
                                          ('support vector regression',
                                           SVR(kernel="rbf",gamma=gam_start,C=c_start,epsilon=eps_start))])
         l=0
         for train, val in folds:
             pipe.fit(X[train], Y[train])
             cv_RMSE[l]=metrics.mean_squared_error(
                     Y[val], pipe.predict(X[val]))**0.5
             l=l+1
             gam_best=gam_start
             c_best=c_start
             eps_best=eps_start
             rpd_best=sample_std/np.mean(cv_RMSE)
             
     elif optimization=="grid":
         # Create a search vector from starting values for gridsearch
         gam_list=np.linspace(gam_start/gridscale,gam_start*gridscale,10)
         c_list=np.linspace(c_start/gridscale,c_start*gridscale,10)
         eps_list=np.linspace(eps_start/gridscale,eps_start*gridscale,10)
         
         # Create list of ndarrays from parameter search vectors,
         # it will help with making the cood more tidy
         param_lists=[gam_list,c_list,eps_list]
         param_best=np.zeros(3)
         rpd_best_all=0
         non_improve=0
         
         repeat=True
         while repeat:
             # Array for storing CV errors
             cv_RMSE_all=np.zeros([len(folds),len(gam_list),len(c_list),len(eps_list)])
             # Put the CV iteration outside to save time when using OSC
             i=0
             for train, val in folds:
                 # If OSC model specified
                 if len(osc_params)==2:
                     osc=OSC(nicomp=osc_params[0],ncomp=osc_params[1])
                     osc.fit(X[train], Y[train])
                     X_train_osc=osc.X_osc
                     X_val_osc=osc.transform(X[val])
                 j=0
                 for gam in param_lists[0]:
                     k=0
                     for c in param_lists[1]:
                         l=0
                         for eps in param_lists[2]: 
                             pipe = Pipeline([('scaler', StandardScaler()),
                                              ('support vector regression', SVR(kernel="rbf",gamma=gam,C=c,epsilon=eps))])
                             if len(osc_params)==2:
                                 pipe.fit(X_train_osc, Y[train])
                                 cv_RMSE_all[i,j,k,l]=metrics.mean_squared_error(
                                     Y[val], pipe.predict(X_val_osc))**0.5
                             else:
                                 pipe.fit(X[train], Y[train])
                                 cv_RMSE_all[i,j,k,l]=metrics.mean_squared_error(
                                         Y[val], pipe.predict(X[val]))**0.5
                             l=l+1
                         k=k+1
                     j=j+1
                 i=i+1
             cv_RMSE=np.mean(cv_RMSE_all,axis=0)
        
             # Best model
             param_best[0]=param_lists[0][np.where(
                     cv_RMSE==np.amin(cv_RMSE))[0][0]]
             param_best[1]=param_lists[1][np.where(
                     cv_RMSE==np.amin(cv_RMSE))[1][0]]
             param_best[2]=param_lists[2][np.where(
                     cv_RMSE==np.amin(cv_RMSE))[2][0]]
             rpd_best=sample_std/np.amin(cv_RMSE)
             # Check against all time best
             if rpd_best>rpd_best_all:
                 param_best_all = param_best.copy()
                 rpd_best_all=rpd_best
             else:
                 # Increase counter if there is no improvement
                 non_improve=non_improve+1
             if verbose==True:
                 print("Best RMSE: ",np.amin(cv_RMSE))
                 print("Best RPD: ",rpd_best)
                 print("Gamma: ",param_best[0])
                 print("C: ",param_best[1])
                 print("Epsilon: ",param_best[2])
             repeat=False
             for index,p in enumerate(param_best):
                 # Check if best value is in IQ range
                 if p<np.quantile(param_lists[index],0.2) or p>np.quantile(param_lists[index],0.8):
                     # If not, move the search interval based on the magnitude of the best value
                     scale=math.floor(math.log10(p))-1
                     lower=p-(10**scale)*5
                     upper=p+(10**scale)*5
                     # If best value is at the extreme of the interval expand it by a lot that way
                     if min(param_lists[index])==p:
                         lower=min(param_lists[index])/2
                     elif max(param_lists[index])==p:
                         upper=max(param_lists[index])*2
                     # Create new search vector
                     param_lists[index]=np.linspace(lower,upper,10)
                     # Repeat evaluation
                     repeat=True
             # Terminate early if no improvements in 10 iterations        
             if non_improve>non_improve_lim:
                 repeat=False
                 print("No improvement, terminate early.")
             if repeat:
                 print("new iteration")
         # Set final values to all time best
         gam_best=param_best_all[0]
         c_best=param_best_all[1]
         eps_best=param_best_all[2]
         rpd_best=rpd_best_all
    
     # Simulated annealing
     elif optimization=="sa":
             # Number of cycles
             cycles = 100
             # Trials per cycle
             trials = 100
             # Number of accepted solutions
             n_accepted = 0.0
             # Probability of accepting worse solution at the start
             p_start = 0.3
             # Probability of accepting worse solution at the end
             p_end = 0.001
             # Initial temperature
             t_start = -1.0/math.log(p_start)
             # Final temperature
             t_end = -1.0/math.log(p_end)
             # Use geometric temp reduction
             frac = (t_end/t_start)**(1.0/(cycles-1.0))
             # Starting values
             t=t_start
             dE_mean = 0.0
             gam=gam_start
             c=c_start
             eps=eps_start
             # Calculate starting cost
             cv_RMSE=np.zeros(len(folds))
             pipe = Pipeline([('scaler', StandardScaler()),
                                  ('support vector regression',
                                   SVR(kernel="rbf",gamma=gam,C=c,epsilon=eps))])
             L=0
             for train, val in folds:
                     pipe.fit(X[train], Y[train])
                     cv_RMSE[L]=metrics.mean_squared_error(
                             Y[val], pipe.predict(X[val]))**0.5
                     L=L+1
             cost=np.mean(cv_RMSE)
             rpd=sample_std/cost
             print("starting RPD:",rpd)
             # Best results
             gam_old = gam
             c_old = c
             eps_old = eps
             cost_old=cost
             rpd_old=rpd
             # All time best result
             gam_best = gam
             c_best = c
             eps_best = eps
             cost_best=cost
             rpd_best = rpd
             for i in range(cycles):
                 if verbose and i%10==0 and i>0:
                     print('Cycle: ', i ,' with Temperature: ', t)
                     print('RPD=',rpd_old,'Gamma='  ,gam_old,', C=' ,c_old,', epsilon=',eps_old)
                 for j in range(trials):
                     # Generate new trial points
                     gam = gam_old + (random.random()-0.5)*2/1000
                     c = c_old + (random.random()-0.5)*2*10
                     eps = eps_old + (random.random()-0.5)*2/100
                     # Enforce lower bounds
                     gam = max(gam,0.0000001)
                     c = max(c,0.0000001)
                     eps = max(eps,0)
                     # Calculate cost
                     cv_RMSE=np.zeros(len(folds))
                     pipe = Pipeline([('scaler', StandardScaler()),
                                          ('support vector regression',
                                           SVR(kernel="rbf",gamma=gam,C=c,epsilon=eps))])
                     L=0
                     for train, val in folds:
                             pipe.fit(X[train], Y[train])
                             cv_RMSE[L]=metrics.mean_squared_error(
                                     Y[val], pipe.predict(X[val]))**0.5
                             L=L+1
                     cost=np.mean(cv_RMSE)
                     rpd=sample_std/cost
                     dE = cost-cost_old
                     # If new cost is higher
                     if dE > 0:
                         if (i==0 and j==0): dE_mean = dE
                         # Generate probability of acceptance
                         p = math.exp(-dE/(dE_mean * t))
                         # Determine whether to accept worse point
                         if (random.random()<p):
                             accept = True
                         else:
                             accept = False
                     else:
                         # New cost is lower, automatically accept
                         accept = True
                         # Check if cost is lower than all time best
                         if cost<cost_best:
                             # If new best, store the parameters, cost and RPD
                             gam_best=gam
                             c_best=c
                             eps_best=eps
                             cost_best=cost
                             rpd_best=rpd
                     if accept==True:
                         # Update parameters, cost and RPD
                         gam_old = gam
                         c_old = c
                         eps_old = eps
                         cost_old=cost
                         rpd_old=rpd
                         # Increment number of accepted solutions
                         n_accepted = n_accepted + 1
                         # Update energy change
                         dE_mean = (dE_mean * (n_accepted-1) +  abs(dE)) / n_accepted
                 # Lower the temperature for next cycle
                 t = frac * t
                 # Return the best setting found
     else:
         raise InputError("Invalid optimization strategy!")
     return (gam_best,c_best,eps_best,rpd_best)
Example #9
0
    def osc_cv(self,nicomp_range=range(10,130,10),ncomp_range=range(1,5),epsilon = 10e-6,
               max_iters = 20,model="pls",model_parameter_range=range(1,11)):
        # Separating X from Y for PLS
        # Needs to be converted to numpy array from pandas df
        X=self.df[self.freqs].to_numpy()
        # Y need to be converted to numpy array from pandas series and reshaped to (N,1) from (N,)
        Y=self.df[self.y_name].to_numpy().reshape(-1, 1)
        # CV based on measurement day
        if self.cval=="MD":
            cv = LeaveOneGroupOut()
            folds=list(cv.split(X=X,y=Y,groups=self.df[self.date_name]))
        # kfold CV
        elif self.cval=="kfold":
            cv = KFold(n_splits=self.cval_param)
            folds=list(cv.split(X))
        else:
            raise InputError("Invalid CV type!")

        #Matrix for cv values for all the possible parameter combinations
        cv_RMSE_all=np.zeros([len(folds),len(model_parameter_range),len(nicomp_range),len(ncomp_range)])
        i=0
        #possible internal component values for osc
        for nicomp in nicomp_range:
            j=0
            #possible removed component values for osc
            for ncomp in ncomp_range:    
                k=0
                for train, val in folds:
                    # train osc
                    osc_obj=OSC("SWosc",nicomp,ncomp,epsilon, max_iters)
                    X_osc_train, W,P,mu_x=osc_obj.fit(X[train],Y[train])
                    # apply osc on validation set
                    # mean center data, alternatively the training set's mean can be used
                    # if you think it is a better estimate by mean="training"
                    X_osc_val=osc_obj.transform(X[val],mean="estimate")
                    l=0                           
                    #possible model patrameter values for pls
                    for param in model_parameter_range:                        
                        #setup pls model
                        pls = PLSRegression(param,scale=False)
                        #train pls
                        pls.fit(X_osc_train, Y[train])
                        #predict with pls and calculate error
                        cv_RMSE_all[k,l,i,j]=metrics.mean_squared_error(
                                Y[val], pls.predict(X_osc_val))**0.5
                        l=l+1
                    k=k+1
                j=j+1
            i=i+1
            
        # Calculate mean performance across the folds
        cv_RMSE_mean=np.mean(cv_RMSE_all,axis=0)
        # Find maximum for every osc paremeter combination
        cv_RMSE=np.amax(cv_RMSE_mean, axis=0)
        cv_RPD=np.std(self.df[self.y_name])/cv_RMSE
        fig = plt.figure(figsize=(10,5))
        ax = plt.axes(projection="3d")
        # Cartesian indexing (x,y) transposes matrix indexing (i,j)
        x, y = np.meshgrid(list(ncomp_range),list(nicomp_range))
        z=cv_RPD
        ls = LightSource(200, 45)
        rgb = ls.shade(z, cmap=cm.gist_earth, vert_exag=0.1, blend_mode='soft')
        surf = ax.plot_surface(x, y, z, rstride=1, cstride=1, facecolors=rgb,
                               linewidth=0, antialiased=False, shade=False)
        plt.show()
        # Best model
        print("Best RMSE: ",np.amin(cv_RMSE))
        print("Best RPD: ",np.std(self.df[self.y_name])/np.amin(cv_RMSE))
        print("Number of internal components: ",nicomp_range[np.where(
                cv_RMSE==np.amin(cv_RMSE))[0][0]])
        print("Number of removed components: ",ncomp_range[np.where(
                cv_RMSE==np.amin(cv_RMSE))[1][0]])
        return cv_RMSE
Example #10
0
class LongWebW(QWidget):
    def __init__(self):
        super(LongWebW, self).__init__()
        self.grid = QGridLayout(self)
        self.osc = OSC()
        self.osc.clear()
        self.view_list = [LongWebView(), LongWebView()] 
        self.view_list[0].setSizePolicy(QSizePolicy.MinimumExpanding,QSizePolicy.Preferred)
        self.view_list[1].setSizePolicy(QSizePolicy.MinimumExpanding,QSizePolicy.Preferred)
        self.onData_list = [[], []] # [[(cur_set, onset),], [(cur_set, onset),]
        self.offData_list = [[], []] # [[(cur_set, offset),], [(cur_set, offset),]
        self.onOff_list = [[], []]
        self.grid.addWidget(self.view_list[0], 0,0,1,1)
        self.grid.addWidget(self.view_list[1], 1,0,1,1)
        self.setMinimumWidth(1200)
        self.setFixedHeight(700)
        self.cur_notes_set = set()
        self.lock = threading.RLock()
        self.idx = 0
        self.auto = False
        self.renewParserT("molihua.abc")

    def closeEvent(self, event):
        print("longwebw close!!")
        self.auto = False
        self.clear()
        self.osc.clear() 

    def clear(self):
        for note in copy.copy(self.cur_notes_set):
            self.noteOff(note)

    def mousePressEvent(self, event):
        print("clicked")
        if self.auto: 
            self.auto = False
            return
        t = threading.Timer(0.1, self.autoPlay)
        t.start()

    def renewParserT(self, file_name):
        self.view_list[0].refresh()
        self.view_list[1].refresh()
        timer = threading.Timer(2 ,self.renewParser, [file_name])
        timer.start()

    def renewParser(self, file_name):
        self.idx = 0;
        self.parser = Parser(file_name)
        self.view_list[0].set_m_k(self.parser.time_sign, self.parser.key_sign).draw_stave()
        self.view_list[1].set_m_k(self.parser.time_sign, self.parser.key_sign).draw_stave()
        self.give_data(0)
        self.give_data(1)
        self.view_list[0].draw_line()
   
    def noteOn(self, nstr, checkMove=True):
        with self.lock:
            self.cur_notes_set.add(nstr)
            if checkMove: self.check_move()
        NIdx = VStrToNIdx(nstr)
        if NIdx >=0: self.osc.noteOn(NIdx)
        

    def noteOff(self, nstr):
        with self.lock:
            if nstr in self.cur_notes_set:
                self.cur_notes_set.remove(nstr)
        NIdx = VStrToNIdx(nstr)
        if NIdx >=0: self.osc.noteOff(NIdx)

    def check_move(self):
        if self.onData_list[self.idx] != [] and self.onData_list[self.idx][0][0].issubset(self.cur_notes_set): # self.cur_notes_set  == self.onData_list[self.idx][0][0]:
            # have to move
            self.onData_list[self.idx].pop(0)
            self.view_list[self.idx].move()
            if self.onData_list[self.idx] == []:
                # last element, have to fetch
                self.give_data(self.idx)
                self.idx = (self.idx+1)%2
                if self.onData_list[self.idx] != []:
                    self.view_list[self.idx].draw_line()

    def set_move_speed(self, speed):
        self.view_list[0].set_move_speed(speed)
        self.view_list[1].set_move_speed(speed)

    def autoPlay(self):
        if self.onData_list[self.idx] == []: return
        self.auto = True
        cur_onset, cur_onval = self.onData_list[self.idx][0]
        ooIdx = 0
        # Jump to current onoff Idx
        while ooIdx < len(self.onOff_list[self.idx]) and self.onOff_list[self.idx][ooIdx][0] != cur_onval:
            ooIdx += 1
            print("ooIdx = " + str(ooIdx))
        start_time = time.time(); cur_sidx = self.idx
        start_val = cur_onval
        self.clear()
        # Start playing
        while self.auto == True and (ooIdx < len(self.onOff_list[self.idx]) or cur_sidx != self.idx):
            if cur_sidx != self.idx: # Rotate to next idx
                ooIdx = 0; cur_sidx = self.idx
                print("Cur Notes Set:::::::" + str(self.cur_notes_set))
                print(self.onOff_list[self.idx][ooIdx:])
                if len(self.onOff_list[self.idx]) == 0: break # No onoff any more
            val, onset, offset = self.onOff_list[self.idx][ooIdx]
            # Sleep until the val
            self.sleep(start_time, start_val, val, self.parser.speed)
            if ooIdx == 0: self.clear()
            with self.lock:
                for each in offset:
                    self.noteOff(each)
                for each in onset:
                    self.noteOn(each, False)
                self.check_move()
            ooIdx += 1
        self.auto = False

    def sleep(self, start_time, start_val ,val, speed):
        target_time = start_time  + (val - start_val)/speed*60
        while time.time() < target_time:
            time.sleep(0.01) 

    def give_data(self, idx):
        data = self.parser.getNext()
        self.build_data_list(data, idx)
        self.build_view_list(data, idx)

    def build_data_list(self, data, idx):
        tre_data = data['tre_notes_raw']
        bas_data = data['bas_notes_raw']
        self.onData_list[idx] = merge2list(tre_data, bas_data,
                                    lambda cur_data: cur_data[0][3],
                                    addToSet, 
                                    lambda res, key, set1, set2: res.append((set1.union(set2), key)),
                                    set(["|"]))
        print("onData_list!!!!!!!!!!!!!")
        print(self.onData_list)
        self.offData_list[idx] = merge2list(tre_data, bas_data,
                                    lambda cur_data: cur_data[0][4],
                                    addToSet,
                                    lambda res, key, set1, set2: res.append((set1.union(set2), key)),
                                    set(["|"]))
        def res_onoff(cur_set, cur_data):
            for each in cur_data[0]:
                cur_set.add(each)
            print(cur_set)
        def append_onoff(res, key, cur_set1, cur_set2):
            print(key, cur_set1, cur_set2)
            res.append((key, cur_set1, cur_set2))
        self.onOff_list[idx] = merge2list(self.onData_list[idx], self.offData_list[idx],
                                    lambda cur_data: cur_data[1],
                                    res_onoff, # lambda cur_set, cur_data: cur_set.union(cur_data[0]),
                                    append_onoff)
        print("onOff_list!!!!!!!!!!!!!")
        print(self.onOff_list)

    def build_view_list(self, data, idx):
        view = self.view_list[idx]
        view.draw_stave()
        view.draw_notes(data)