def main():
"Several runs with different seeds but same random initial conditions (Chebyshev polinomial)."
coef_ord_combo = random_coeff_order_combinations(2)
# pretrain policy means based on some random chebyshev polinomial with fixed standar deviation
identifiers, desired_controls = chebys_tracer(coef_ord_combo,
CONFIG.time_points,
zipped=True)
desired_deviation = 2.0
config = deepcopy(CONFIG)
# add initial controls identifiers to config
labels = multilabel_cheby_identifiers(identifiers)
config.initial_controls_labels = labels
print(f"Initial controls {labels}")
# repeat simulation with different seeds
for _ in range(config.distinct_seeds):
training_pipeline(config, desired_controls, desired_deviation)
# plot results
Plotter("SimpleModel", config).plot_everything()
Plotter("ComplexModel", config).plot_everything()
def show_plot(self, df):
plot = Plotter(
df, **{
'start': self.start,
'stop': self.stop,
'name': self.file_name
})
plot.raw_data_chart()
user_input = input(
'Ist die Messzeit in Ordnung? (y) falls nicht bitte neue Werte für Beginn und '
'Ende der Messung angeben (start, ende)')
return user_input
def calculate_permeability(self, guess, parameter='k'):
if self.find_file():
user_input = input('Bereits angepasste Messdaten nutzen? (y/n')
if user_input == 'y':
self.set_adjusted_data()
elif user_input == 'n':
self.set_data()
else:
self.set_data()
result = Optimizer(self.df_100, self.sample_data, guess)
result, opt_steps = result.nelder_mead(parameter)
plot = Plotter(self.df_100, **{'name': self.file_name})
plot.result_chart()
self.add_results(result, guess)
user_input = input('Ergebnis abspeichern? (y)')
if user_input == 'y':
self.save_adjusted_measurement_file()
self.save_results()
def main():
""" main functions """
global __logger
load_ini_config()
agent_config = __game_config['agents']
game_config = __game_config['game']
with open('logging.yaml', 'r') as f:
logging.config.dictConfig(yaml.safe_load(f.read()))
__logger = logging.getLogger(__name__)
game_config['logger'] = logging.getLogger('game')
agent_config['logger'] = logging.getLogger('agent')
agent_config['episodes'] = game_config['episodes']
# Optionally Get F, M, and Population Overrides from CLI
parser = argparse.ArgumentParser(description='F,M,Population Overrides')
parser.add_argument('--F',
type=int,
default=game_config['F'])
parser.add_argument('--M',
type=int,
default=game_config['M'])
parser.add_argument('--P',
type=int,
default=game_config['population_size'])
args = parser.parse_args()
game_config['F'] = args.F
game_config['M'] = args.M
game_config['population_size'] = args.P
__logger.info(args)
game_config['timestamp'] = datetime.datetime.utcnow().isoformat()
game_config['output_directory'] = setup_directory(game_config)
game_config['plotter'] = Plotter(agent_config, game_config)
game = Game(agent_config, game_config)
game.play_game(game_config['episodes'])
def plots_for_boroughs(self):
''' Return Plots by Borough'''
plotter = Plotter(self.query())
return plotter.borough_plots()
def plots_for_zip_code(self, zip_code):
''' Return Plots by Zipcode'''
zipdata = self.query({ 'zip_code' : zip_code})
plotter = Plotter(zipdata, "ZIP: %s" % zip_code)
return plotter.all_plots()
# M: frame orientation 45 degrees to 40 intervals.
# M: 20 to 25 frames.
stimuli = {'rods': rods, 'frames': frames}
# initialize generative agent
genAgent = GenerativeAgent(params_gen, stimuli)
# initialize psi object
psi = PSI_RiF(params, stimuli)
# number of iterations of the experiment
iterations_num = 500
# initialize plotter and plot generative distribution, generative weights and the negative log likelihood
plotter = Plotter(params, params_gen, stimuli, genAgent, psi, iterations_num)
plotter.plotGenProbTable()
plotter.plotGenVariances()
plotter.plotGenWeights()
plotter.plotGenPSE()
plotter.plotNegLogLikelihood(responses_num=500)
plotter.plot()
for stim_selection in ['adaptive', 'random']:
# set stimulus selection mode and reset psi object to initial values
psi.reset(stim_selection)
# reset plotter to plot new figures
plotter.reset()
# run model for given number of iterations
import flask
from flask import request, abort, Response
import json
from executor import Executor
from plots import Plotter, PlotterError
app = flask.Flask(__name__)
executor = Executor()
plotter = Plotter()
@app.route('/', methods=['GET'])
def home():
return '''<h1>Welcome to the REST service for SymPy</h1>
'''
@app.route('/api/v1/custom', methods=['POST'])
def execute_custom():
if not request.json:
abort(400, "no json provided as the request body")
method = request.json["method"]
if 'method' not in request.json:
abort(400, "no 'method' field found in the JSON")
if 'args' not in request.json:
abort(400, "no 'args' field found in the JSON")
args = request.json["args"]
result = executor.run_custom(method, args)
def plots_for_boroughs(self):
''' Return Plots by Borough'''
plotter = Plotter(self.query())
return plotter.borough_plots()
def plots_for_zip_code(self, zip_code):
''' Return Plots by Zipcode'''
zipdata = self.query({'zip_code': zip_code})
plotter = Plotter(zipdata, "ZIP: %s" % zip_code)
return plotter.all_plots()
def main():
# Maybe delete this ?
group = 'lung'
parser = argparse.ArgumentParser(description='classifier')
parser.add_argument('--sample_file', type=str, default='lung.emx.txt', help="the name of the GEM organized by samples (columns) by genes (rows)")
parser.add_argument('--label_file', type=str, default='sample_condition.txt', help="name of the label file: two columns that maps the sample to the label")
parser.add_argument('--output_name', type=str, default='tissue-run-1', help="name of the output directory to store the output files")
#parser.add_argument('--overwrite_output', type=bool, default=False, help="overwrite the output directory file if it already exists")
parser.add_argument('--batch_size', type=int, default=16, help="size of batches to split data")
parser.add_argument('--max_epoch', type=int, default=100, help="number of passes through a dataset")
parser.add_argument('--learning_rate', type=float, default=0.001, help="controls the rate at which the weights of the model update")
parser.add_argument('--test_split', type=float, default=0.3, help="percentage of test data, the train data will be the remaining data. 30% -> 0.3")
parser.add_argument('--continuous_discrete', type=str, default='continuous', help="type of data in the sample file, typically RNA will be continous and DNA will be discrete")
parser.add_argument('--plot_results', type=bool, default=True, help="plots the sample distribution, training/test accuracy/loss, and confusion matrix")
parser.add_argument('--use_gpu', type=bool, default=False, help="true to use a gpu, false to use the cpu - if the node does not have a gpu then it will use the cpu")
args = parser.parse_args()
#If data is discrete, data should only range between 0-3
#if args.continuous_discrete == "discrete":
#args.input_num_classes = 4
# Initialize file paths and create output folder
LABEL_FILE = os.path.join(INPUT_DIR, args.label_file)
SAMPLE_FILE = os.path.join(INPUT_DIR, args.sample_file)
OUTPUT_DIR_FINAL = os.path.join(OUTPUT_DIR, args.output_name + "-" + str(datetime.today().strftime('%Y-%m-%d-%H:%M')))
if not os.path.exists(OUTPUT_DIR_FINAL):
os.makedirs(OUTPUT_DIR_FINAL)
# Create log file to keep track of model parameters
logging.basicConfig(filename=os.path.join(OUTPUT_DIR_FINAL,'classifier.log'),
filemode='w',
format='%(message)s',
level=logging.INFO)
logger = logging.getLogger(__name__)
logger.info('Classifer log file for ' + args.sample_file + ' - Started on ' + str(datetime.today().strftime('%Y-%m-%d-%H:%M')) + '\n')
logger.info('Batch size: %d', args.batch_size)
logger.info('Number of epochs: %d', args.max_epoch)
logger.info('Learning Rate: %f', args.learning_rate)
logger.info('Sample filename: ' + args.sample_file)
logger.info('Output directory: ' + args.output_name)
if args.continuous_discrete != 'continuous' and args.continuous_discrete != 'discrete':
logger.error("ERROR: check that the continuous_discrete argument is spelled correctly.")
logger.error(" only continuous or discrete data can be processed.")
sys.exit("\nCommand line argument error. Please check the log file.\n")
# Intialize gpu usage if desired
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda and args.use_gpu else "cpu")
train_kwargs = {'batch_size': 16}
test_kwargs = {'batch_size': 16}
if use_cuda:
cuda_kwargs = {'num_workers': 1,
'pin_memory': True,
'shuffle': True}
train_kwargs.update(cuda_kwargs)
test_kwargs.update(cuda_kwargs)
# Load matrix, labels/weights, and number of samples
column_names = ("sample", "label")
matrix_df = pd.read_csv(SAMPLE_FILE, sep='\t', index_col=[0])
labels_df = pd.read_csv(LABEL_FILE, names=column_names, delim_whitespace=True, header=None)
# Error checking for same number of samples in both files and samples are unique
samples_unique = set(labels_df.iloc[:,0])
assert len(labels_df) == len(matrix_df.columns)
assert len(labels_df) == len(samples_unique)
labels, class_weights = preprocessing.labels_and_weights(labels_df)
args.output_num_classes = len(labels)
is_binary = False
if len(labels) == 2:
is_binary = True
args.output_num_classess = 1
# Define model paramters
batch_size = args.batch_size
max_epoch = args.max_epoch
learning_rate = args.learning_rate #5e-4
num_features = len(matrix_df.index)
# Setup model
model = utils.Net(input_seq_length=num_features,
output_num_classes=args.output_num_classes).to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.1)
if is_binary:
loss_fn = torch.nn.BCEWithLogitsLoss()
else:
loss_fn = torch.nn.CrossEntropyLoss()#(weight=class_weights)
logger.info('Number of samples: %d\n', len(labels_df))
logger.info('Labels: ')
for i in range(len(labels)):
logger.info(' %d - %s', i, labels[i])
# Replace missing data with the global minimum of the dataset
val_min, val_max = np.nanmin(matrix_df), np.nanmax(matrix_df)
matrix_df.fillna(val_min, inplace=True)
# Transposing matrix to align with label file
matrix_transposed_df = matrix_df.T
# Create density and tsne plot
graphs = Plotter(OUTPUT_DIR_FINAL)
graphs.density(matrix_df)
graphs.tsne(matrix_transposed_df, labels_df, labels, title=args.sample_file)
train_data, test_data = preprocessing.split_data(matrix_transposed_df, labels_df, args.test_split, args.output_num_classes)
# Convert tuple of df's to tuple of np's
# Allows the dataset class to access w/ data[][] instead of data[].iloc[]
train_data_np = (train_data[0].values, train_data[1].values)
test_data_np = (test_data[0].values, test_data[1].values)
train_dataset = dataset.Dataset(train_data_np)
test_dataset = dataset.Dataset(test_data_np)
train_generator = data.DataLoader(train_dataset, **train_kwargs, drop_last=False)
test_generator = data.DataLoader(test_dataset, **test_kwargs, drop_last=False)
# drop_last=True would drop the last batch if the sample size is not divisible by the batch size
logger.info('\nTraining size: %d \nTesting size: %d\n', len(train_dataset), len(test_dataset))
# Create variables to store accuracy and loss
loss_meter = utils.AverageMeter()
loss_meter.reset()
summary_file = pd.DataFrame([], columns=['Epoch', 'Training Loss', 'Accuracy', 'Accurate Count', 'Total Items'])
train_stats = pd.DataFrame([], columns=['accuracy', 'loss'])
test_stats = pd.DataFrame([], columns=['accuracy', 'loss'])
# Train and test the model
for epoch in range(args.max_epoch):
train_stats = train(model, device, is_binary, train_generator, optimizer, loss_fn, batch_size, loss_meter, train_stats)
test_stats = test(model, device, is_binary, test_generator, loss_fn, epoch, batch_size, loss_meter, test_stats, train_stats, logger)
scheduler.step()
# Training finished - Below is used for testing the network, plots and saving results
if(args.plot_results):
y_predict_list = []
y_target_list = []
y_predict_list, y_target_list = forward(model, device, is_binary, test_generator, y_predict_list, y_target_list)
graphs.accuracy(train_stats, test_stats, graphs_title=args.sample_file)
graphs.confusion(y_predict_list, y_target_list, labels, cm_title=args.sample_file)
logger.info("\n\nf1 score: %0.2f" % (f1_score(y_target_list, y_predict_list, average="weighted")))
#summary_file.to_csv(RESULTS_FILE, sep='\t', index=False)
logger.info('\nFinal Accuracy: %2.3f', test_stats.iloc[epoch]['accuracy'])
logger.info('\nFinished at ' + str(datetime.today().strftime('%Y-%m-%d-%H:%M')))
# initialize generative agent
genAgent = GenerativeAgent(params_gen, stimuli)
# initialize psi object
psi = PSI_RiF(params, stimuli)
# number of iterations of the experiment and (current) number of experiments
iterations_num = 500
experiments_num = 2
current_experiment_num = 0
# initialize plotter and plot generative distribution, weights, SDs and bias and the negative log likelihood
plotter = Plotter(params,
params_gen,
stimuli,
genAgent,
psi,
iterations_num,
plot_period=25)
plotter.plotGenProbTable()
plotter.plotGenStandardDeviations()
plotter.plotGenWeights()
plotter.plotGenPSE()
plotter.plotNegLogLikelihood(responses_num=500)
plotter.plot()
# initialize printer and print generative standard deviations, weights and bias
printer = Printer(params, stimuli, genAgent, psi, iterations_num,
experiments_num)
printer.printGenStandardDeviations()
printer.printGenWeights()
