#!/bin/bash
#SBATCH -n 1 # Number of cores
#SBATCH -N 1 # Ensure that all cores are on one machine
#SBATCH -t 0-10:00 # Runtime in D-HH:MM
#SBATCH -p serial_requeue # Partition to submit to
#SBATCH --mem=5000 # Memory pool for all cores (see also --mem-per-cpu)
#SBATCH -o OUTPUTDIR/out_%j.txt # File to which STDOUT will be written
#SBATCH -e OUTPUTDIR/err_%j.txt # File to which STDERR will be written

python your_code.py # how to run your job

############################################################################
# Global Options
############################################################################
# large history
set-option -g history-limit 10000

# utf8 support
set-window-option -g utf8 on

# Automatically set window title
setw -g automatic-rename on

# Fast typing!
set-option -sg escape-time 1

# Key settings
set-window-option -g xterm-keys on # for vim
set-window-option -g mode-keys emacs
set-option -g status-keys emacs

# show activity
set-window-option -g monitor-activity on
set -g visual-activity on

# window title
set-option -g set-titles on
set-option -g set-titles-string '#H:#W'

# global colors
set-option -g default-terminal "screen-256color" #"xterm-256color" # "screen-256color"

# additional-menu colors
setw -g mode-bg black
setw -g mode-fg white

# pane border colors
set-option -g pane-active-border-fg white
set-option -g pane-active-border-bg white

# By default, all windows in a session are constrained to the size of the 
# smallest client connected to that session, 
# even if both clients are looking at different windows. 
# It seems that in this particular case, Screen has the better default 
# where a window is only constrained in size if a smaller client 
# is actively looking at it.
setw -g aggressive-resize on


############################################################################
# Status Bar
############################################################################
set-option -g status-utf8 on
set-option -g status-justify right
set-option -g status-bg black
set-option -g status-fg white
set-option -g status-interval 4
set-option -g status-left-length 130
set-option -g status-left '#[fg=cyan]#(date +"%-I:%M%p %b-%d")'
set-option -g status-right ''

set-window-option -g window-status-current-fg white
set-window-option -g window-status-current-bg black
#setw -g window-status-current-attr reverse
set-window-option -g window-status-format ' #I '
set-window-option -g window-status-current-format '#[fg=green][#[default]#I#[fg=green]]'

############################################################################
# Bindings & Unbindings
############################################################################

# reload tmux conf
bind-key r source-file ~/.tmux.conf \; display-message "Configuration reloaded"
 
# split horizontally
unbind '"'
bind-key - split-window -v

# split vertically
unbind %
bind-key \ split-window -h
 
 # Navigation: use the vim motion keys to move between panes
bind-key -r h select-pane -L
bind-key -r j select-pane -D
bind-key -r k select-pane -U
bind-key -r l select-pane -R
  
# Pane Resizing
bind-key -r H resize-pane -L
bind-key -r J resize-pane -D
bind-key -r K resize-pane -U
bind-key -r L resize-pane -R

# Pane Maximizing [Don't switch windows between using these]
unbind <
bind < new-window -d -n tmux-zoom 'clear && echo TMUX ZOOM && read' \; swap-pane -s tmux-zoom.0 \; select-window -t tmux-zoom
unbind >
bind > last-window \; swap-pane -s tmux-zoom.0 \; kill-window -t tmux-zoom

# in-scroll-mode commands
bind-key -t emacs-copy C-v page-down
bind-key -t emacs-copy C-f page-up

# Even out all panes in the current window
bind | select-layout "even-vertical"
bind _ select-layout "even-horizontal"

import json
import os
import sys

# If this flag is set to True, the jobs won't be submitted to SLURM;
# they will instead be ran one after another in your current terminal
# session. You can use this to either run a sequence of jobs locally
# on your machine, or to run a sequence of jobs one after another
# in an interactive shell.
DRYRUN = True

# This is the base directory where the results will be stored.
# In SLURM, you may not want this to be your home directory
# If you're storing lots of files (or storing a lot of data).
OUTPUT_DIR = 'output'

# This list contains the jobs and hyper-parameters to search over.
# The list consists of tuples, in which the first element is
# the name of the job (here it describes the method we are using)
# and the second is a dictionary of parameters that will be
# be grid-searched over. That is, for the first item in the QUEUE below,
# the following jobs will be ran:
# 1. dataset='mnist', learning_rate=0.01
# 2. dataset='uci', learning_rate=0.001
# 3. dataset='mnist', learning_rate=0.001
# 4. dataset='uci', learning_rate=0.01
# Note that the second parameter must be a dictionary in which each
# value is a list of options.
QUEUE = [
    ('neural_network', dict(dataset=['mnist', 'uci'], learning_rate=[0.01, 0.001])),
    ('gaussian_process', dict(dataset=['mnist', 'uci'], optimize_lenscale=[True, False])),
]


def run(exp_dir, exp_name, exp_kwargs):
    '''
    This is the function that will actually execute the job.
    To use it, here's what you need to do:
    1. Create directory 'exp_dir' as a function of 'exp_kwarg'.
       This is so that each set of experiment+hyperparameters get their own directory.
    2. Get your experiment's parameters from 'exp_kwargs'
    3. Run your experiment
    4. Store the results however you see fit in 'exp_dir'
    '''
    print('Running experiment {}:'.format(exp_name))
    print('Results are stored in:', exp_dir)
    print('with hyperparameters', exp_kwargs)
    print('\n')


def main():
    assert(len(sys.argv) > 2)

    exp_dir = sys.argv[1]
    exp_name = sys.argv[2]
    exp_kwargs = json.loads(sys.argv[3])
    
    run(exp_dir, exp_name, exp_kwargs)


if __name__ == '__main__':
    main()

import os
import copy
import sys
import itertools
import json
import subprocess
import socket

from run import (
    run,
    QUEUE,
    DRYRUN,
    OUTPUT_DIR,
)


TMP_DIR = 'tmp'
TEMPLATE = 'template.sh'


def safe_zip(*args):
    if len(args) > 0:
        first = args[0]
        for a in args[1:]:
            assert(len(a) == len(first))

    return list(zip(*args))


def submit_job(output_dir, template, exp_name, exp_kwargs):
    exp_dir = os.path.join(output_dir, exp_name)
    if not os.path.exists(exp_dir):
        os.makedirs(exp_dir)

    script = copy.deepcopy(template)
    script = script.replace('EXPNAME', exp_name)
    script = script.replace('EXPDIR', exp_dir)
    script = script.replace('KWARGS', "'{}'".format(json.dumps(exp_kwargs)))
    
    sname = os.path.join(TMP_DIR, 'slurm_{}.sh'.format(exp_name))
    with open(sname, 'w') as f:
        f.write(script)
    
    if not DRYRUN:
        ret = subprocess.call('sbatch {}'.format(sname).split(' '))
        if ret != 0:
            print('Error code {} when submitting job for {}'.format(ret, sname))
    else:
        run(exp_dir, exp_name, exp_kwargs)
    

def main():
    # Create the directory where your results will go.
    # In this directory you can make a sub-directory for each experiment you run.
    # Experiments are listed in the 'QUEUE' variable above
    if not os.path.exists(OUTPUT_DIR):
        os.makedirs(OUTPUT_DIR)

    # Create a temporary directory for the slurm scripts
    # that are automatically generated by this script
    if not os.path.exists(TMP_DIR):
        os.makedirs(TMP_DIR)

    # Read in the template so we can modify it programmatically
    with open(TEMPLATE, 'r') as f:
        template = f.read()

    # For each experiment, create a job for every combination of parameters
    for experiment_name, params in QUEUE:
        for vals in itertools.product(*list(params.values())):
            exp_kwargs = dict(safe_zip(params.keys(), vals))
            submit_job(OUTPUT_DIR, template, experiment_name, exp_kwargs)


if __name__ == '__main__':
    main()

#!/bin/bash
#SBATCH -n 1 # Number of cores
#SBATCH -N 1 # Ensure that all cores are on one machine
#SBATCH -t 0-10:00 # Runtime in D-HH:MM
#SBATCH -p test # partition
#SBATCH --mem=10000 # Memory pool for all cores (see also --mem-per-cpu)
#SBATCH -o EXPDIR/out_%j.txt # File to which STDOUT will be written
#SBATCH -e EXPDIR/err_%j.txt # File to which STDERR will be written

python -u run.py EXPDIR EXPNAME KWARGS