Merge branch 'master' of https://github.com/PPPLDeepLearning/plasma-python

Author: Julian Kates-Harbeck

data/signals.py

@@ -176,10 +176,10 @@ def fetch_nstx_data(signal_path,shot_num,c):
 pin = Signal("Input Power (beam for d3d)",['jpf/gs/bl-ptot<s','d3d/bmspinj'],[jet,d3d]) #Total Beam Power
 
 pradtot = Signal("Radiated Power",['jpf/db/b5r-ptot>out'],[jet])
-pradcore = ChannelSignal("Radiated Power Core",[ 'd3d/'+r'\bol_l15_p'],[d3d])
-pradedge = ChannelSignal("Radiated Power Edge",['d3d/'+r'\bol_l03_p'],[d3d])
-#pradcore = ChannelSignal("Radiated Power Core",['ppf/bolo/kb5h/channel14', 'd3d/'+r'\bol_l15_p'],[jet,d3d])
-#pradedge = ChannelSignal("Radiated Power Edge",['ppf/bolo/kb5h/channel10','d3d/'+r'\bol_l03_p'],[jet,d3d])
+#pradcore = ChannelSignal("Radiated Power Core",[ 'd3d/'+r'\bol_l15_p'],[d3d])
+#pradedge = ChannelSignal("Radiated Power Edge",['d3d/'+r'\bol_l03_p'],[d3d])
+pradcore = ChannelSignal("Radiated Power Core",['ppf/bolo/kb5h/channel14', 'd3d/'+r'\bol_l15_p'],[jet,d3d])
+pradedge = ChannelSignal("Radiated Power Edge",['ppf/bolo/kb5h/channel10','d3d/'+r'\bol_l03_p'],[jet,d3d])
 # pechin = Signal("ECH input power, not always on",['d3d/pcechpwrf'],[d3d])
 pechin = Signal("ECH input power, not always on",['RF/ECH.TOTAL.ECHPWRC'],[d3d])
 
@@ -238,6 +238,7 @@ def fetch_nstx_data(signal_path,shot_num,c):
 fully_defined_signals = {sig_name: sig for (sig_name, sig) in all_signals_restricted.items() if sig.is_defined_on_machines(all_machines)}
 d3d_signals = {sig_name: sig for (sig_name, sig) in all_signals_restricted.items() if sig.is_defined_on_machine(d3d)}
 jet_signals = {sig_name: sig for (sig_name, sig) in all_signals_restricted.items() if sig.is_defined_on_machine(jet)}
+jet_signals_0D = {sig_name: sig for (sig_name, sig) in all_signals_restricted.items() if (sig.is_defined_on_machine(jet) and sig.num_channels == 1)}
 
 
 #['pcechpwrf'] #Total ECH Power Not always on!

examples/extract_best_overtime.py

@@ -0,0 +1,159 @@
+import pandas as pd
+import glob
+from subprocess import Popen
+import yaml
+import os
+import math
+import numpy as np
+from random import shuffle
+from joblib import Parallel, delayed
+import multiprocessing
+
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pylab as plt
+
+import pdb
+
+def arrangeTrialsAtRandom(filenames,scale=1.0):
+    shuffle(filenames)
+    previous = pd.read_csv(filenames[0])
+    previous['times'] = previous['times'].apply(lambda x: x/60.0/scale)
+    dataframes = [previous]
+    for filename in filenames[1:]:
+        shift = max(previous['times'].values)
+        current = pd.read_csv(filename)
+        current['times'] = current['times'].apply(lambda x: x/60.0/scale+shift)
+        dataframes.append(current)
+        previous = current
+    return pd.concat(dataframes)
+
+def getOneBestValidationAUC(T_of_test,dataset):
+    #select subset of dataframe by time for all
+    dataset = dataset[dataset.times <= T_of_test]
+ 
+    #apply emulate_converge script
+    aucs = dataset['val_roc'].values
+    if len(aucs) > 0:
+        return max(aucs)
+    else:
+        return 0.0
+
+def doPlot(parallel_aucs, serial_aucs, times, errors):
+    times = list(times)
+    times_histo = np.histogram(parallel_aucs,bins=times)
+    #values,edges = times_histo
+    parallel_values = parallel_aucs[1:]
+    edges = times
+    print(len(parallel_values))
+    print(len(edges))
+    serial_values = np.array(serial_aucs[1:])
+    errors = np.array(errors[1:])
+    edges = np.array(times[:-1])
+    print(errors.shape)
+    print(edges.shape)
+    print(serial_values.shape)
+
+
+    plt.figure()
+    plt.plot(edges, parallel_values,label = "Distributed search") #, width=np.diff(edges), ec="k", align="edge")
+    plt.plot(edges, serial_values, label="Sequential search") #, width=np.diff(edges), ec="k", align="edge")
+    #plt.fill_between(edges, serial_values-errors,serial_values+errors)
+    plt.legend(loc = (0.6,0.7))
+    plt.xlabel("Time [minutes]", fontsize=20)
+    #plt.yscale('log')
+    plt.ylabel('Best validation AUC', fontsize=20)
+    plt.savefig("times.png")
+
+    plt.figure()
+    plt.plot(edges, parallel_values,label = "Distributed search") #, width=np.diff(edges), ec="k", align="edge")
+    plt.plot(edges, serial_values, label="Sequential search") #, width=np.diff(edges), ec="k", align="edge")
+    #plt.fill_between(edges, serial_values-errors,serial_values+errors)
+    plt.legend(loc = (0.6,0.7))
+    plt.xlabel("Time [minutes]", fontsize=20)
+    plt.xscale('log')
+    plt.xlim([0,100])
+    plt.ylabel('Best validation AUC', fontsize=20)
+    plt.savefig("times_logx_start.png")
+
+    plt.figure()
+    plt.plot(edges, parallel_values,label = "Distributed search") #, width=np.diff(edges), ec="k", align="edge")
+    plt.plot(edges, serial_values, label="Sequential search") #, width=np.diff(edges), ec="k", align="edge")
+    #plt.fill_between(edges, serial_values-errors,serial_values+errors)
+    plt.legend(loc = (0.6,0.7))
+    plt.xlabel("Time [minutes]", fontsize=20)
+    plt.xscale('log')
+    plt.xlim([100,10000])
+    plt.ylabel('Best validation AUC', fontsize=20)
+    plt.savefig("times_logx.png")
+
+
+def getReplica(filenames, times):
+    serial_auc_replica = arrangeTrialsAtRandom(filenames,100.0)
+
+    best_serial_aucs_over_time = []
+    for T in times:
+        current_best = 0
+        ##pass AUCs and real epoch counts to emulate_converge
+        auc = getOneBestValidationAUC(T,serial_auc_replica)
+        if auc > current_best: current_best = auc
+
+        best_serial_aucs_over_time.append(current_best)
+
+    #replicas.append(best_serial_aucs_over_time)
+    return best_serial_aucs_over_time
+
+def getTimeReplica(filenames,T):
+    current_best = 0
+    for filename in filenames:
+        #get AUCs for this trial, one per effective epoch
+        try:
+            dataset = pd.read_csv(filename)
+            dataset['times'] = dataset['times'].apply(lambda x: x/60.0)
+        except:
+            print("No data in {}".format(filename))
+            continue
+        ##pass AUCs and real epoch counts to emulate_converge
+        auc = getOneBestValidationAUC(T,dataset)
+        if auc > current_best: current_best = auc
+    return current_best
+
+def getTimeReplicaSerial(serial_auc_replica,T):
+    current_best = 0
+    ##pass AUCs and real epoch counts to emulate_converge
+    auc = getOneBestValidationAUC(T,serial_auc_replica)
+    if auc > current_best: current_best = auc
+
+    #replicas.append(best_serial_aucs_over_time)
+    return current_best
+
+
+if __name__ == '__main__':
+
+    filenames = glob.glob("/tigress/FRNN/JET_Titan_hyperparameter_run/*/temporal_csv_log.csv")
+    patience = 5
+
+    times = np.linspace(0,310*30,186*30)
+
+    best_parallel_aucs_over_time = []
+    num_cores = multiprocessing.cpu_count()
+    print ("Running on ", num_cores, " CPU cores")
+    best_parallel_aucs_over_time = Parallel(n_jobs=num_cores)(delayed(getTimeReplica)(filenames, T) for T in times) 
+
+    Nreplicas = 20
+    replicas = []
+
+
+    for i in range(Nreplicas):
+        serial_auc_replica = arrangeTrialsAtRandom(filenames,100.0)
+
+        #replicas = Parallel(n_jobs=num_cores)(delayed(getReplica)(filenames, times) for i in range(Nreplicas)) 
+        best_serial_aucs_over_time = Parallel(n_jobs=num_cores)(delayed(getTimeReplicaSerial)(serial_auc_replica, T) for T in times)
+        replicas.append(best_serial_aucs_over_time)
+
+
+    from statistics import mean,stdev
+    best_serial_aucs_over_time = list(map(mean, zip(*replicas)))
+    errors = list(map(stdev, zip(*replicas)))
+
+    doPlot(best_parallel_aucs_over_time, best_serial_aucs_over_time, times, errors)

plasma/conf_parser.py

@@ -83,6 +83,10 @@ def parameters(input_file):
             params['paths']['shot_files'] = [jet_carbon_wall]
             params['paths']['shot_files_test'] = [jet_iterlike_wall]
             params['paths']['use_signals_dict'] = jet_signals
+        elif params['paths']['data'] == 'jet_data_0D':
+            params['paths']['shot_files'] = [jet_carbon_wall]
+            params['paths']['shot_files_test'] = [jet_iterlike_wall]
+            params['paths']['use_signals_dict'] = jet_signals_0D
         elif params['paths']['data'] == 'jet_carbon_data':
             params['paths']['shot_files'] = [jet_carbon_wall]
             params['paths']['shot_files_test'] = []

plasma/primitives/data.py

@@ -253,7 +253,7 @@ def fetch_data(self,machine,shot_num,c):
 
 
 class ChannelSignal(Signal):
-    def __init__(self,description,paths,machines,tex_label=None,causal_shifts=None,mapping_range=(0,1),num_channels=32,data_avail_tolerances=None,is_strictly_positive=False,mapping_paths=None):
+    def __init__(self,description,paths,machines,tex_label=None,causal_shifts=None,data_avail_tolerances=None,is_strictly_positive=False,mapping_paths=None):
         super(ChannelSignal, self).__init__(description,paths,machines,tex_label,causal_shifts,is_ip=False,data_avail_tolerances=data_avail_tolerances,is_strictly_positive=is_strictly_positive,mapping_paths=mapping_paths)
         nums,new_paths = self.get_channel_nums(paths)
         self.channel_nums = nums