PythonDataset/train/ctlearn-task-instances.jsonl.all

{"repo": "ctlearn-project/ctlearn", "pull_number": 29, "instance_id": "ctlearn-project__ctlearn-29", "issue_numbers": "", "base_commit": "9842660d4293a485652ccfe48725fda3d5be9e33", "patch": "diff --git a/ctalearn/data.py b/ctalearn/data.py\ndeleted file mode 100644\n--- a/ctalearn/data.py\n+++ /dev/null\n@@ -1,556 +0,0 @@\n-from operator import itemgetter\n-import threading\n-import logging\n-import math\n-from collections import OrderedDict\n-import random\n-\n-import tables\n-import numpy as np\n-import cv2\n-\n-from ctalearn.image import MAPPING_TABLES, IMAGE_SHAPES\n-\n-logger = logging.getLogger(__name__)\n-\n-# dict mapping CORSIKA particle ids to class number\n-PARTICLE_ID_TO_CLASS = {101:0, 0:1}\n-# dict mapping class number to particle name\n-CLASS_TO_NAME = {0:'proton',1:'gamma'}\n-\n-# Multithread-safe PyTables open and close file functions\n-# See http://www.pytables.org/latest/cookbook/threading.html\n-lock = threading.Lock()\n-\n-def synchronized_open_file(*args, **kwargs):\n-    with lock:\n-        return tables.open_file(*args, **kwargs)\n-\n-def synchronized_close_file(self, *args, **kwargs):\n-    with lock:\n-        return self.close(*args, **kwargs)\n-\n-# Externally store the file handles corresponding to each filename.\n-# This structures allow the load_data functions to read from HDF5 files without\n-# the expensive need to open and close them for each event.\n-# NOTE: this function makes use of the fact that dicts as default arguments are\n-# mutable. That is, after something is added to file_handle_dict in one\n-# function call, it will still be there the next time the function is called.\n-def return_file_handle(filename, file_handle_dict={}):\n-    if filename not in file_handle_dict:\n-        file_handle_dict[filename] = synchronized_open_file(\n-                filename.decode('utf-8'), mode='r')\n-    return file_handle_dict[filename]\n-\n-# Data loading function for event-wise (array-level) HDF5 data loading\n-def load_data_eventwise_HDF5(filename, index, auxiliary_data, metadata,\n-        settings):\n-\n-    # Read the event record for the given filename and index\n-    f = return_file_handle(filename)\n-    record = f.root.Event_Info[index]\n-    \n-    # Get classification label by converting CORSIKA particle code\n-    gamma_hadron_label = PARTICLE_ID_TO_CLASS[record['particle_id']]\n-   \n-    # Collect image indices (indices into the image tables)\n-    # for each telescope type in this event\n-    telescope_types = settings['processed_telescope_types']\n-    image_indices = {tel_type:record[tel_type+\"_indices\"] for tel_type in\n-            telescope_types}\n-    # Collect images, auxiliary info, and binary trigger values\n-    telescope_images = []\n-    telescope_triggers = []\n-    shower_positions = [] # only used when cropping images\n-    for tel_type in telescope_types:\n-        image_shape = settings['processed_image_shapes'][tel_type]\n-        for i in image_indices[tel_type]:\n-            if i == 0:\n-                # Telescope did not trigger. Its outputs will be dropped\n-                # out, so input is arbitrary. Use an empty array for\n-                # efficiency.\n-                telescope_images.append(np.zeros(image_shape))\n-                if settings['crop_images']:\n-                    shower_positions.append([0, 0])\n-                telescope_triggers.append(0)\n-            else:\n-                telescope_image = load_image_HDF5(f, tel_type, i)\n-                if settings['crop_images']:\n-                    telescope_image, *shower_position = crop_image(\n-                            telescope_image, settings)\n-                    shower_positions.append([float(i)/metadata['image_shapes'][tel_type][0] for i in shower_position])\n-                if settings['log_normalize_charge']:\n-                    telescope_image[:,:,0] = np.log(telescope_image[:,:,0] - metadata['image_charge_min'][tel_type] + 1.0)\n-                telescope_images.append(telescope_image)\n-                telescope_triggers.append(1)\n-   \n-    if settings['use_telescope_positions']:\n-        telescope_positions = []\n-        for tel_type in telescope_types:\n-            # Collect telescope positions from auxiliary data\n-            # telescope_positions is a list of lists\n-            # ex. [[x1,y1,z1],[x2,y2,z2],...]\n-            for tel_id in sorted(auxiliary_data['telescope_positions'][tel_type].keys()):\n-                # normalize the x, y and z coordinates in the telescope position based on the maximum value of each\n-                x, y, z = auxiliary_data['telescope_positions'][tel_type][tel_id]\n-                tel_pos = [float(x)/metadata['max_telescope_pos'][0], float(y)/metadata['max_telescope_pos'][1], float(z)/metadata['max_telescope_pos'][2]] \n-                telescope_positions.append(tel_pos)\n-\n-    # Construct telescope auxiliary inputs as specified\n-    telescope_aux_inputs = []\n-    for aux_input in settings['processed_aux_input_nums'].keys():\n-        if aux_input == 'telescope_position':\n-            telescope_aux_inputs.append(telescope_positions)\n-        elif aux_input == 'shower_position':\n-            telescope_aux_inputs.append(shower_positions)\n-    # Group parameters by telescope\n-    telescope_aux_inputs = [tel_params for [*tel_params] in\n-            zip(*telescope_aux_inputs)]\n-    # For each telescope, merge the parameters into a single list\n-    telescope_aux_inputs = [[param for param_list in tel_list for param in\n-        param_list] for tel_list in telescope_aux_inputs]\n-\n-    if settings['sort_telescopes_by_trigger']:\n-        # Sort the images, triggers, and grouped auxiliary inputs by\n-        # trigger, listing the triggered telescopes first\n-        \"\"\"\n-        telescope_images, telescope_triggers, telescope_aux_inputs = map(list,\n-                zip(*sorted(zip(telescope_images, telescope_triggers,\n-                    telescope_aux_inputs), reverse=True, key=itemgetter(1))))\n-        \"\"\"\n-\n-        telescope_images, telescope_triggers, telescope_aux_inputs = map(list,\n-                zip(*sorted(zip(telescope_images, telescope_triggers,\n-                    telescope_aux_inputs), reverse=True, key=lambda x: np.sum(x[0]))))\n-      \n-    # Convert to numpy arrays with correct types\n-    telescope_images = np.stack(telescope_images).astype(np.float32)\n-    telescope_triggers = np.array(telescope_triggers, dtype=np.int8)\n-    telescope_aux_inputs = np.array(telescope_aux_inputs, dtype=np.float32)\n-\n-    return [telescope_images, telescope_triggers, telescope_aux_inputs,\n-            gamma_hadron_label]\n-\n-# Data loading function for single tel HDF5 data\n-# Loads the image in file 'filename', in image table 'tel_type' at index 'index'\n-def load_data_single_tel_HDF5(filename, index, metadata, settings):\n-\n-    # Load image table record from specified file and image table index\n-    f = return_file_handle(filename)\n-    tel_type = settings['processed_telescope_types'][0]\n-    telescope_image = load_image_HDF5(f, tel_type, index)\n-    if settings['crop_images']:\n-        telescope_image, _, _ = crop_image(telescope_image, settings)\n-    if settings['log_normalize_charge']:\n-        telescope_image[:,:,0] = np.log(telescope_image[:,:,0] - metadata['image_charge_min'][tel_type] + 1.0)\n-\n-    # Get corresponding event record using event_index column\n-    event_index = f.root._f_get_child(tel_type)[index]['event_index']\n-    event_record = f.root.Event_Info[event_index]\n-\n-    # Get classification label by converting CORSIKA particle code\n-    gamma_hadron_label = PARTICLE_ID_TO_CLASS[event_record['particle_id']]\n-\n-    return [telescope_image, gamma_hadron_label]\n-\n-# Return dict of auxiliary data values (currently only contains telescope position coordinates).\n-# Structured as auxiliary_data[telescope_positions][tel_type][tel_id] = [x,y,z]\n-# Checks that the same telescopes have the same position across all files.\n-def load_auxiliary_data_HDF5(file_list): \n-    # Load telescope positions by telescope type and id\n-    telescope_positions = {}\n-    for filename in file_list:\n-        with tables.open_file(filename, mode='r') as f:\n-            # For every telescope in the file\n-            for row in f.root.Array_Info.iterrows():\n-                tel_type = row['tel_type'].decode('utf-8')\n-                tel_id = row['tel_id']\n-                if tel_type not in telescope_positions:\n-                    telescope_positions[tel_type] = {}\n-                if tel_id not in telescope_positions[tel_type]:\n-                        telescope_positions[tel_type][tel_id] = [row[\"tel_x\"],\n-                                row[\"tel_y\"], row[\"tel_z\"]]\n-                else:\n-                    if telescope_positions[tel_type][tel_id] != [row[\"tel_x\"],\n-                            row[\"tel_y\"], row[\"tel_z\"]]:\n-                        raise ValueError(\"Telescope positions do not match for telescope {} in file {}.\".format(tel_id,filename))\n-    \n-    auxiliary_data = {\n-            'telescope_positions': telescope_positions\n-            }\n-    \n-    return auxiliary_data\n-\n-def load_metadata_HDF5(file_list):\n-    num_events_by_file, particle_id_by_file , num_images_by_file = [], [], {}\n-    telescope_types, telescope_ids = [], {}\n-    image_charge_min, image_charge_max = {}, {}\n-    for filename in file_list:\n-        with tables.open_file(filename, mode='r') as f:\n-            num_events_by_file.append(f.root.Event_Info.shape[0])\n-            # Particle ID is same for all events in a given file and\n-            # is therefore saved in the root attributes\n-            particle_id_by_file.append(f.root._v_attrs.particle_type)\n-            # Build telescope types list and telescope ids dict for current file\n-            # NOTE: telescope types list is sorted in order of tel_ids\n-            tel_ids_types, tel_ids_types_temp = [], []\n-            for row in f.root.Array_Info.iterrows():\n-                # note: tel type strings stored in Pytables as byte strings, must be decoded\n-                tel_type = row['tel_type'].decode('utf-8')\n-                tel_id = row['tel_id']\n-                tel_ids_types_temp.append((tel_id,tel_type))\n-            # sort all (telescope id, telescope type) pairs by tel_id\n-            tel_ids_types_temp.sort(key=lambda i: i[0])\n-           \n-            #get max x, y, z telescope coordinates\n-            max_tel_x = max(row['tel_x'] for row in f.root.Array_Info.iterrows())\n-            max_tel_y = max(row['tel_y'] for row in f.root.Array_Info.iterrows())\n-            max_tel_z = max(row['tel_z'] for row in f.root.Array_Info.iterrows())\n-\n-            max_telescope_pos = [max_tel_x, max_tel_y, max_tel_z]\n-\n-            # Check that telescope types and ids match across all files\n-            if tel_ids_types != tel_ids_types_temp:\n-                if not tel_ids_types:\n-                    tel_ids_types = tel_ids_types_temp\n-                else:\n-                    raise ValueError(\"Telescope type/id mismatch in file {}\".format(filename))\n-           \n-            # save sorted list of telescope types\n-            if not telescope_types:\n-                for tel_id, tel_type in tel_ids_types:\n-                    if tel_type not in telescope_types: \n-                        telescope_types.append(tel_type)\n-            \n-            # save dict of telescope_ids\n-            if not telescope_ids:\n-                for tel_id, tel_type in tel_ids_types:\n-                    if tel_type not in telescope_ids:\n-                        telescope_ids[tel_type] = []\n-                    telescope_ids[tel_type].append(tel_id)\n-            \n-            # Save dict of number of images by tel type per telescope\n-            # for single tel data\n-            # Subtract one since index 0 corresponds to a blank template\n-            for tel_type in telescope_types:\n-                if tel_type not in num_images_by_file:\n-                    num_images_by_file[tel_type] = []\n-                num_images_by_file[tel_type].append(\n-                        f.root._f_get_child(tel_type).shape[0] - 1)\n-\n-            # Compute dataset image max and min for normalization\n-            for tel_type in telescope_types:\n-                tel_table = f.root._f_get_child(tel_type)\n-                record = tel_table.read(1,tel_table.shape[0])\n-                images = record['image_charge']\n-\n-                if tel_type not in image_charge_min:\n-                    image_charge_min[tel_type] = np.amin(images)\n-                if tel_type not in image_charge_max:\n-                    image_charge_max[tel_type] = np.amax(images)\n-\n-                if np.amin(images) < image_charge_min[tel_type]:\n-                    image_charge_min[tel_type] = np.amin(images)\n-                if np.amax(images) > image_charge_max[tel_type]:\n-                    image_charge_max[tel_type] = np.amax(images)\n-\n-    metadata = {\n-            'num_events_by_file': num_events_by_file,\n-            'num_telescopes': {tel_type:len(telescope_ids[tel_type]) for tel_type in telescope_types},\n-            'telescope_ids': telescope_ids,\n-            'telescope_types': telescope_types,\n-            'num_images_by_file': num_images_by_file,\n-            'particle_id_by_file': particle_id_by_file,\n-            'image_shapes': IMAGE_SHAPES,\n-            'class_to_name': CLASS_TO_NAME,\n-            'num_classes': len(set(particle_id_by_file)),\n-            'num_position_coordinates': 3,\n-            'image_charge_min': image_charge_min,\n-            'image_charge_max': image_charge_max,\n-            'max_telescope_pos': max_telescope_pos\n-            }\n-\n-    return metadata\n-\n-# Use the data processing settings from the user and metadata from the dataset\n-# to determine the final parameters of the data after processing. This is\n-# needed for passing to the model and for efficient data loading.\n-# Save the processed parameters in both dictionaries.\n-def add_processed_parameters(data_processing_settings, metadata):\n-    \n-    # Choose telescope types for this event. They must be available in the\n-    # data, chosen in the settings, and have a MAPPING_TABLE\n-    # NOTE: Only MSTS has a MAPPING_TABLE so far regardless of chosen types\n-    available_telescope_types = metadata['telescope_types']\n-    chosen_telescope_types = data_processing_settings['chosen_telescope_types']\n-    processed_telescope_types = [ttype for ttype in available_telescope_types\n-            if ttype in chosen_telescope_types and ttype in MAPPING_TABLES]\n-    \n-    # If single telescope mode, check that only one telescope type is enabled\n-    if data_processing_settings['model_type'] == 'singletel':\n-        if not len(processed_telescope_types) == 1:\n-            raise ValueError('Exactly one telescope type must be enabled for single telescope models, number requested is: {}'.format(len(processed_telescope_types)))\n-\n-    processed_parameters = {\n-            'processed_telescope_types': processed_telescope_types,\n-            'processed_image_shapes': {},\n-            'processed_num_telescopes': {},\n-            'processed_aux_input_nums': OrderedDict()\n-            }\n-\n-    # Determine the processed image size which will be different if cropping\n-    for tel_type in processed_telescope_types:\n-        if data_processing_settings['crop_images']:\n-            processed_image_shape = (\n-                    data_processing_settings['bounding_box_size'],\n-                    data_processing_settings['bounding_box_size'],\n-                    metadata['image_shapes'][tel_type][2])\n-        else:\n-            processed_image_shape = metadata['image_shapes'][tel_type]\n-        processed_parameters['processed_image_shapes'][tel_type] = processed_image_shape\n-        processed_parameters['processed_num_telescopes'][tel_type] = metadata['num_telescopes'][tel_type]\n-\n-    # Calculate the total number of auxiliary inputs\n-    if data_processing_settings['use_telescope_positions']:\n-        processed_parameters['processed_aux_input_nums']['telescope_position'] = metadata['num_position_coordinates']\n-    if data_processing_settings['crop_images']:\n-        # Image centroid x, y\n-        processed_parameters['processed_aux_input_nums']['shower_position'] = data_processing_settings['num_shower_coordinates']\n-\n-    data_processing_settings.update(processed_parameters)\n-    metadata.update(processed_parameters)\n-\n-def load_image_HDF5(data_file,tel_type,index):\n-    \n-    record = data_file.root._f_get_child(tel_type)[index]\n-    \n-    # Allocate empty numpy array of shape (len_trace + 1,) to hold trace plus\n-    # \"empty\" pixel at index 0 (used to fill blank areas in image)\n-    trace = np.empty(shape=(record['image_charge'].shape[0] + 1),dtype=np.float32)\n-    # Read in the trace from the record \n-    trace[0] = 0.0\n-    trace[1:] = record['image_charge']\n-    \n-    # Create image by indexing into the trace using the mapping table, then adding a\n-    # dimension to given shape (length,width,1)\n-    telescope_image = np.expand_dims(trace[MAPPING_TABLES[tel_type]],2)\n-  \n-    return telescope_image\n-\n-# Function to get all indices in each HDF5 file which pass a provided cut condition\n-# For single tel mode, returns all MSTS image table indices from events passing the cuts\n-# For array-level mode, returns all event table indices from events passing the cuts\n-# Cut condition must be a string formatted as a Pytables selection condition\n-# (i.e. for table.where()). See Pytables documentation for examples.\n-# If cut condition is empty, do not apply any cuts.\n-def apply_cuts_HDF5(file_list, cut_condition, model_type, min_num_tels=1):\n-\n-    if cut_condition:\n-        logger.info(\"Cut condition: %s\", cut_condition)\n-    else:\n-        logger.info(\"No cuts applied.\")\n-\n-    indices_by_file = []\n-    for filename in file_list:\n-        # No need to use the multithread-safe file open, as this function\n-        # is only called once\n-        with tables.open_file(filename, mode='r') as f:\n-            # For single tel, get all passing events, then collect all non-zero \n-            # MSTS image indices into a flat list\n-            event_table = f.root.Event_Info\n-            if model_type == 'singletel':\n-                rows = [row for row in event_table.where(cut_condition)] if cut_condition else event_table.iterrows()\n-                indices = [i for row in rows for i in row['MSTS_indices'] if np.count_nonzero(row['MSTS_indices']) >= min_num_tels if i != 0]\n-            # For array-level get all passing rows and return a list of all of\n-            # the indices\n-            else:\n-                rows = [row for row in event_table.where(cut_condition)] if cut_condition else event_table.iterrows()\n-                # Enforce that only events containing at least one MSTS are \n-                # included. This is necessary because PyTables cut conditions\n-                # cannot operate on multidimensional fields.\n-                indices = [row.nrow for row in rows if np.count_nonzero(row['MSTS_indices']) >= min_num_tels]\n-\n-        indices_by_file.append(indices)\n-\n-    return indices_by_file\n-\n-def split_indices_lists(indices_lists,validation_split):\n-    training_lists = []\n-    validation_lists = []\n-    for indices_list in indices_lists:\n-       num_validation = math.ceil(validation_split * len(indices_list))\n-       \n-       training_lists.append(indices_list[num_validation:len(indices_list)])\n-       validation_lists.append(indices_list[0:num_validation])\n-\n-    return training_lists,validation_lists\n-\n-# Generator function used to produce a dataset of elements (HDF5_filename,index)\n-# from a list of files and a list of lists of indices per file (constructed by applying cuts)\n-def gen_fn_HDF5(file_list,indices_by_file, shuffle=True):\n-    # produce all filename,index pairs and shuffle\n-    filename_index_pairs = [(filename,i) for (filename, indices_list) in zip(file_list,indices_by_file) for i in indices_list]\n-    if shuffle:\n-        random.shuffle(filename_index_pairs)\n-\n-    for (filename,i) in filename_index_pairs:\n-        yield (filename.encode('utf-8'),i)\n-\n-def get_data_generators_HDF5(file_list, metadata, settings, mode='train'):\n-\n-    # Get number of examples by file\n-    if settings['model_type'] == 'singletel': # get number of images\n-        telescope_type = settings['processed_telescope_types'][0]\n-        num_examples_by_file = metadata['num_images_by_file'][telescope_type]\n-    else: # get number of events\n-        num_examples_by_file = metadata['num_events_by_file']\n-\n-    # Log general information on dataset based on metadata dictionary\n-    logger.info(\"%d data files read.\", len(file_list))\n-    logger.info(\"Telescopes in data:\")\n-    for tel_type in metadata['telescope_ids']:\n-        logger.info(tel_type + \": \"+'[%s]' % ', '.join(map(str,metadata['telescope_ids'][tel_type]))) \n-    \n-    num_examples_by_label = {}\n-    for i,num_examples in enumerate(num_examples_by_file):\n-        particle_id = metadata['particle_id_by_file'][i]\n-        if particle_id not in num_examples_by_label: num_examples_by_label[particle_id] = 0\n-        num_examples_by_label[particle_id] += num_examples\n-\n-    total_num_examples = sum(num_examples_by_label.values())\n-\n-    logger.info(\"%d total examples.\", total_num_examples)\n-    logger.info(\"Num examples by label:\")\n-    for label in num_examples_by_label:\n-        logger.info(\"%s: %d (%f%%)\", label, num_examples_by_label[label], 100 * float(num_examples_by_label[label])/total_num_examples)\n-\n-    # Apply cuts\n-    indices_by_file = apply_cuts_HDF5(file_list, settings['cut_condition'], settings['model_type'], min_num_tels=settings['min_num_tels'])\n-\n-    # Log info on cuts\n-    num_passing_examples_by_label = {}\n-    for i,index_list in enumerate(indices_by_file):\n-        num_passing_examples = len(index_list)\n-        particle_id = metadata['particle_id_by_file'][i]\n-        if particle_id not in num_passing_examples_by_label:\n-            num_passing_examples_by_label[particle_id] = 0\n-        num_passing_examples_by_label[particle_id] += num_passing_examples\n-\n-    num_passing_examples = sum(num_passing_examples_by_label.values())\n-\n-    logger.info(\"%d total examples passing cuts.\", num_passing_examples)\n-    logger.info(\"Num examples by label:\")\n-    for label in num_passing_examples_by_label:\n-        logger.info(\"%s: %d (%f%%)\", label, num_passing_examples_by_label[label], 100 * float(num_passing_examples_by_label[label])/num_passing_examples)\n-\n-    # Add post-cut computed class weights to metadata dictionary\n-    metadata['class_weights'] = [] \n-    for particle_id in sorted(num_passing_examples_by_label,key=lambda x: PARTICLE_ID_TO_CLASS[x]):\n-        metadata['class_weights'].append(num_passing_examples/float(num_passing_examples_by_label[particle_id]))\n-\n-    if mode == 'train':\n-        # Split indices lists into training and validation\n-        training_indices, validation_indices = split_indices_lists(indices_by_file,\n-                settings['validation_split'])\n-\n-        def training_generator():\n-            return gen_fn_HDF5(file_list,training_indices)\n-        def validation_generator():\n-            return gen_fn_HDF5(file_list,validation_indices)\n-\n-        return training_generator, validation_generator\n-\n-    elif mode == 'test':\n-\n-        def test_generator():\n-            return gen_fn_HDF5(file_list, indices_by_file, shuffle=False)\n-\n-        return test_generator\n-\n-# Crop an image about the shower center, optionally applying image cleaning\n-# to obtain a better fit. The shower centroid is calculated as the mean of\n-# pixel positions weighted by the charge, after cleaning. The cropped image is\n-# obtained as a square bounding box centered on the centroid of side length\n-# bounding_box_size.\n-def crop_image(image, settings):\n-\n-    # Apply image cleaning\n-    image_cleaning_method = settings['image_cleaning_method']\n-    if image_cleaning_method == \"none\":\n-        # Don't apply any cleaning\n-        cleaned_image = image\n-    elif image_cleaning_method == \"twolevel\":\n-        # Apply two-level cleaning to isolate the shower. First, filter for\n-        # shower pixels by applying a high charge cut (picture threshold).\n-        # Next, retain weaker pixels at the shower edge by allowing pixels\n-        # adjacent to those passing the first cut to pass a weaker cut\n-        # (boundary threshold).\n-        \n-        # Get only the first channel (charge) of an image of arbitrary depth\n-        image_charge = image[:,:,0]\n-\n-        # Apply picture threshold to charge image to get mask\n-        m = (image_charge > settings['picture_threshold']).astype(np.uint8)\n-        # Dilate the mask once to add all adjacent pixels (i.e. kernel is 3x3)\n-        kernel = np.ones((3,3), np.uint8) \n-        m = cv2.dilate(m, kernel)\n-        # Apply boundary threshold to keep weaker but adjacent pixels\n-        m = (m * image_charge > settings['boundary_threshold']).astype(np.uint8)\n-        m = np.expand_dims(m, 2)\n-\n-        # Multiply by the mask to get the cleaned image\n-        cleaned_image = image * m\n-    else:\n-        raise ValueError('Unrecognized image cleaning method: {}'.format(\n-            image_cleaning_method))\n-\n-    # compute image moments, then use them to compute the centroid\n-    # coordinates (x_0, y_0)\n-    # NOTE: x_0 refers to a coordinate value along array axis 0 (rows, top to bottom)\n-    # y_0 refers to a coordinate value along array axis 1 (columns, left to right)\n-    # NOTE: when the image is blank after cleaning (sum of pixels is 0), set the\n-    # centroid to center of image to avoid divide by zero errors\n-    moments = cv2.moments(cleaned_image[:,:,0])\n-    x_0 = moments['m01']/moments['m00'] if moments['m00'] != 0 else image.shape[1]/2\n-    y_0 = moments['m10']/moments['m00'] if moments['m00'] != 0 else image.shape[0]/2\n-\n-    # compute min and max x and y indices (along axis 0 and axis 1 respectively)\n-    # NOTE: these values are rounded and cast to integers, so they are valid indices\n-    # into the array\n-    # NOTE: rounding (and subtracting one from the max values) ensures that for all\n-    # float values of x_0, y_0, the values of indices x_min, x_max, y_min, y_max mark \n-    # a bounding box of exactly shape (BOUNDING_BOX_SIZE, BOUNDING_BOX_SIZE)\n-    bounding_box_size = settings['bounding_box_size']\n-    x_min = int(round(x_0 - bounding_box_size/2))\n-    x_max = int(round(x_0 + bounding_box_size/2)) - 1\n-    y_min = int(round(y_0 - bounding_box_size/2))\n-    y_max = int(round(y_0 + bounding_box_size/2)) - 1\n-\n-    cropped_image = np.zeros((bounding_box_size,bounding_box_size,image.shape[2]),dtype=np.float32)\n-\n-    # indices into the original image array which correspond to the bounding box region\n-    # when the bounding box goes over the edge of the original image array,\n-    # we truncate the appropriate indices so that all of x_min_image, x_max_image, etc.\n-    # are valid indices into the array\n-    x_min_image = x_min if x_min >= 0 else 0\n-    x_max_image = x_max if x_max <= (image.shape[0] - 1) else (image.shape[0] -1)\n-    y_min_image = y_min if y_min >= 0 else 0\n-    y_max_image = y_max if y_max <= (image.shape[1] - 1) else (image.shape[1] -1)\n-\n-    # indices into the cropped image array of shape (BOUNDING_BOX_SIZE,BOUNDING_BOX_SIZE,image.shape[2])\n-    # which correspond to the region described by x_min, x_max, etc. in the original\n-    # image array. The region of the cropped image array which does not correspond to valid \n-    # positions in the original image (the part which goes over the edges) are left filled\n-    # with zeros as padding.\n-    x_min_cropped = -x_min if x_min < 0 else 0\n-    x_max_cropped = (bounding_box_size - (x_max - x_max_image) - 1) if x_max >= (image.shape[0] - 1) else bounding_box_size - 1\n-    y_min_cropped = -y_min if y_min < 0 else 0\n-    y_max_cropped = (bounding_box_size - (y_max - y_max_image) - 1) if y_max >= (image.shape[1] - 1) else bounding_box_size - 1\n-\n-    # transfer the cropped portion of the image array into the smaller, padded cropped_image array.\n-    # Use either the cleaned or uncleaned image as specified\n-    returned_image = (cleaned_image if settings['return_cleaned_images'] else image)\n-    cropped_image[x_min_cropped:x_max_cropped+1,y_min_cropped:y_max_cropped+1,:] = returned_image[x_min_image:x_max_image+1,y_min_image:y_max_image+1,:]\n-\n-    return cropped_image, x_0, y_0\n-\ndiff --git a/ctalearn/data_loading.py b/ctalearn/data_loading.py\nnew file mode 100644\n--- /dev/null\n+++ b/ctalearn/data_loading.py\n@@ -0,0 +1,572 @@\n+from operator import itemgetter\n+import threading\n+import math\n+from collections import OrderedDict\n+import random\n+from abc import ABC, abstractmethod\n+\n+import tables\n+import numpy as np\n+\n+from ctalearn.data_processing import DataProcessor\n+from ctalearn.image_mapping import ImageMapper\n+\n+# Maps CORSIKA particle id codes\n+# to particle class names\n+PARTICLE_ID_TO_NAME = {\n+        0: 'gamma',\n+        101:'proton'\n+        } \n+\n+# General abstract class for loading CTA event data from a dataset\n+# stored in some file format.\n+# Provided as a template for the implementation of alternative data formats \n+# for storing training data.\n+class DataLoader(ABC):\n+\n+    @abstractmethod\n+    def get_image(self):\n+        pass\n+\n+    @abstractmethod\n+    def get_example(self):\n+        pass\n+   \n+    # return a standard collection of metadata parameters describing the data\n+    @abstractmethod\n+    def get_metadata(self):\n+        pass\n+\n+    # return a dictionary of auxiliary data\n+    @abstractmethod\n+    def get_auxiliary_data(self):\n+        pass\n+\n+    @abstractmethod\n+    def get_example_generators(self):\n+        pass\n+\n+# PyTables HDF5 implementation of DataLoader\n+# Corresponds to standard CTA ML format specified by\n+# ImageExtractor (https://github.com/cta-observatory/image-extractor).\n+class HDF5DataLoader(DataLoader):\n+\n+    @staticmethod\n+    def __synchronized_open_file(*args, **kwargs):\n+        with threading.Lock() as lock:\n+            return tables.open_file(*args, **kwargs)\n+\n+    @staticmethod\n+    def __synchronized_close_file(self, *args, **kwargs):\n+        with threading.Lock() as lock:\n+            return self.close(*args, **kwargs)\n+\n+    def __init__(self, \n+            file_list,\n+            mode=\"train\",\n+            example_type=\"array\",\n+            selected_tel_type='MSTS',\n+            selected_tel_ids=None,\n+            min_num_tels=1,\n+            cut_condition=\"\",\n+            validation_split=0.1,\n+            use_telescope_positions=True,\n+            data_processor=None,\n+            image_mapper=ImageMapper(None),\n+            seed=None\n+            ):\n+\n+        # construct dict of filename:file_handle pairs \n+        self.files = {filename:self.__synchronized_open_file(filename, mode='r')\n+                    for filename in file_list}\n+\n+        # Data loading settings\n+        self.mode = mode \n+        self.example_type = example_type\n+        self.cut_condition = cut_condition\n+        self.min_num_tels = min_num_tels\n+        self.validation_split = validation_split\n+        self.use_telescope_positions = use_telescope_positions\n+        self.data_processor = data_processor\n+        self.seed = seed\n+\n+        # Overwrite self._image_mapper with the ImageMapper of the DataProcessor\n+        # if one is provided.\n+        self._image_mapper = image_mapper\n+        if self.data_processor is not None:\n+            self._image_mapper = self.data_processor._image_mapper\n+\n+        # Compute and save metadata describing dataset\n+        self._load_metadata()\n+        \n+        # Select desired telescopes\n+        self._select_telescopes(selected_tel_type, tel_ids=selected_tel_ids)\n+\n+        # Apply cuts to get lists of valid examples\n+        self._apply_cuts()\n+\n+        # Based on example_type and selected telescopes, compute the generator\n+        # output datatypes and map_fn output datatypes.\n+        # NOTE: these dtypes will ultimately be converted to TF datatypes using\n+        # tf.as_dtype()\n+        if self.example_type == 'single_tel':\n+            self.generator_output_dtypes = [np.dtype(np.int64), np.dtype(np.int64), np.dtype(np.int64)] \n+            \n+            data_dtypes = [np.dtype(np.float32)]\n+            label_dtypes = [np.dtype(np.int64)]\n+\n+            self.output_names = ['telescope_data', 'gamma_hadron_label']\n+            self.output_is_label = [False, True]\n+            self.map_fn_output_dtypes = data_dtypes + label_dtypes\n+                    \n+        elif self.example_type == 'array':\n+            self.generator_output_dtypes = [np.dtype(np.int64), np.dtype(np.int64)] \n+           \n+            data_dtypes = [np.dtype(np.float32), \n+                   np.dtype(np.int8),\n+                   np.dtype(np.float32)\n+                   ]\n+\n+            label_dtypes = [np.dtype(np.int64)]\n+            \n+            self.output_names = ['telescope_data', 'telescope_triggers', 'telescope_aux_inputs', 'gamma_hadron_label']\n+            self.output_is_label = [False, False, False, True]\n+            self.map_fn_output_dtypes = data_dtypes + label_dtypes\n+\n+    def add_data_processor(self, data_processor):\n+        if isinstance(data_processor, DataProcessor):\n+            self.data_processor = data_processor\n+        else:\n+            raise ValueError(\"Must provide a DataProcessor object.\")\n+        self._image_mapper = self.data_processor._image_mapper\n+\n+    # Compute and save a collection of metadata parameters\n+    # which describe the dataset\n+    def _load_metadata(self):\n+\n+        self.particle_ids = set()\n+\n+        # OrderedDict with telescope types as keys and list of telescope ids\n+        # of each type (in sorted order) as values\n+        # NOTE: the telescope types are ordered by increasing telescope id\n+        self.telescopes = OrderedDict()\n+\n+        self.events = [] \n+        self.images = {}\n+\n+        self.num_events = 0\n+        self.num_images = {}\n+\n+        self.num_events_by_particle_id = {}\n+        self.num_images_by_particle_id = {}\n+\n+        self.num_position_coordinates = 3\n+        self.telescope_positions = {}\n+        self.max_telescope_positions = {}\n+ \n+        self.image_charge_mins = {}\n+        self.image_charge_maxes = {}\n+       \n+        self.__events_to_indices = {}\n+        self.__single_tel_examples_to_indices = {}\n+\n+        self.__tel_id_to_type_index = {}\n+\n+        for filename in self.files:\n+            # get file handle\n+            f = self.files[filename]\n+            # Particle ID is same for all events in a given file and\n+            # is therefore saved in the root attributes\n+            particle_id = f.root._v_attrs.particle_type\n+            self.particle_ids.add(particle_id)\n+\n+            tel_ids_types = []\n+            for row in f.root.Array_Info.iterrows():\n+                # note: tel type strings stored in Pytables as byte strings, must be decoded\n+                tel_type = row['tel_type'].decode('utf-8')\n+                tel_id = row['tel_id']\n+                tel_ids_types.append((tel_id,tel_type))\n+                if tel_type not in self.telescope_positions:\n+                    self.telescope_positions[tel_type] = {}\n+                if tel_id not in self.telescope_positions[tel_type]:\n+                    self.telescope_positions[tel_type][tel_id] = [row[\"tel_x\"],\n+                                row[\"tel_y\"], row[\"tel_z\"]]\n+                else:\n+                    if self.telescope_positions[tel_type][tel_id] != [row[\"tel_x\"],\n+                            row[\"tel_y\"], row[\"tel_z\"]]:\n+                        raise ValueError(\"Telescope positions do not match for telescope {} in file {}.\".format(tel_id,filename))\n+\n+            # sort all (telescope id, telescope type) pairs by tel_id\n+            tel_ids_types.sort(key=lambda i: i[0])\n+\n+            # For every telescope in the file\n+            for row in f.root.Array_Info.iterrows():\n+                tel_type = row['tel_type'].decode('utf-8')\n+                tel_id = row['tel_id']\n+                \n+            telescopes = OrderedDict()\n+            index = 0\n+            prev_tel_type = tel_ids_types[0][1]\n+            for tel_id, tel_type in tel_ids_types:\n+                if tel_type not in telescopes:\n+                    telescopes[tel_type] = []\n+                telescopes[tel_type].append(tel_id)\n+                self.__tel_id_to_type_index[tel_id] = (tel_type,index)\n+                if tel_type != prev_tel_type:\n+                    index = 0\n+                else:\n+                    index += 1\n+                prev_tel_type = tel_type\n+\n+            if not self.telescopes:\n+                self.telescopes = telescopes\n+            else:\n+                if self.telescopes != telescopes:\n+                    raise ValueError(\"Telescope type/id mismatch in file {}\".format(filename))\n+\n+            # Compute max x, y, z telescope coordinates for normalization\n+            max_tel_x = max(row['tel_x'] for row in f.root.Array_Info.iterrows())\n+            max_tel_y = max(row['tel_y'] for row in f.root.Array_Info.iterrows())\n+            max_tel_z = max(row['tel_z'] for row in f.root.Array_Info.iterrows())\n+\n+            self.max_telescope_position = [max_tel_x, max_tel_y, max_tel_z]\n+            \n+            for row in f.root.Event_Info.iterrows():\n+                if particle_id not in self.num_events_by_particle_id:\n+                    self.num_events_by_particle_id[particle_id] = 0\n+\n+                self.events.append((row['run_number'],row['event_number']))\n+                self.__events_to_indices[(row['run_number'],row['event_number'])] = (filename, row.nrow)\n+\n+                self.num_events_by_particle_id[particle_id] += 1\n+                self.num_events += 1\n+\n+                for tel_type in self.telescopes:\n+                    tel_ids = self.telescopes[tel_type]\n+                    indices = row[tel_type + '_indices']\n+                    if not tel_type in self.num_images:\n+                        self.num_images[tel_type] = 0\n+                    if not tel_type in self.images:\n+                        self.images[tel_type] = []\n+                    if not tel_type in self.num_images_by_particle_id:\n+                        self.num_images_by_particle_id[tel_type] = {}\n+                    for tel_id, image_index in zip(tel_ids, indices):\n+                        self.__single_tel_examples_to_indices[(row['run_number'], row['event_number'], tel_id)] = (filename, tel_type, image_index)\n+                        if image_index != 0:\n+                            self.images[tel_type].append((row['run_number'], row['event_number'], tel_id))\n+                            self.num_images[tel_type] += 1\n+                            if particle_id not in self.num_images_by_particle_id[tel_type]:\n+                                self.num_images_by_particle_id[tel_type][particle_id] = 0\n+                            self.num_images_by_particle_id[tel_type][particle_id] += 1\n+\n+            # Compute max and min pixel value in each telescope image\n+            # type for normalization\n+            # NOTE: This step is time-intensive.\n+            for tel_type in self.telescopes.keys():\n+                tel_table = f.root._f_get_child(tel_type)\n+                records = tel_table.read(1,tel_table.shape[0])\n+                images = records['image_charge']\n+\n+                if tel_type not in self.image_charge_mins:\n+                    self.image_charge_mins[tel_type] = np.amin(images)\n+                if tel_type not in self.image_charge_maxes:\n+                    self.image_charge_maxes[tel_type] = np.amax(images)\n+\n+                if np.amin(images) < self.image_charge_mins[tel_type]:\n+                    self.image_charge_mins[tel_type] = np.amin(images)\n+                if np.amax(images) > self.image_charge_maxes[tel_type]:\n+                    self.image_charge_maxes[tel_type] = np.amax(images)\n+        \n+            # create mapping from particle ids to labels\n+            # and from labels to names\n+            self.ids_to_labels = {particle_id:i \n+                    for i, particle_id in enumerate(sorted(list(self.particle_ids)))}\n+            self.labels_to_names = {i:PARTICLE_ID_TO_NAME[particle_id] \n+                    for particle_id, i in self.ids_to_labels.items()}\n+\n+    # Method returning a dict of selected metadata parameters\n+    def get_metadata(self):\n+\n+        metadata = {\n+                'num_classes': len(list(self.particle_ids)),\n+                'particle_ids': self.particle_ids,\n+                'telescopes': self.telescopes,\n+                'num_telescopes': {self.selected_telescope_type: len(self.selected_telescopes)},\n+                'selected_telescope_types': [self.selected_telescope_type],\n+                'num_events_by_particle_id': self.num_events_by_particle_id,\n+                'num_images_by_particle_id': self.num_images_by_particle_id,\n+                'num_position_coordinates': self.num_position_coordinates,\n+                'class_to_name': self.labels_to_names\n+           }\n+\n+        if self.data_processor is not None:\n+            metadata = {**metadata, **self.data_processor.get_metadata()}\n+\n+        metadata['total_aux_params'] = 0\n+        if self.use_telescope_positions:\n+            metadata['total_aux_params'] += 3\n+        metadata['total_aux_params'] += metadata['num_additional_aux_params']\n+\n+        return metadata\n+\n+    # Return dictionary of auxiliary data.\n+    def get_auxiliary_data(self):\n+        auxiliary_data = {\n+            'telescope_positions': self.telescope_positions\n+            }\n+\n+        return auxiliary_data\n+\n+    # Select which telescopes from the full dataset to include in each event \n+    # by a telescope type and an optional list of telescope ids.\n+    def _select_telescopes(self, tel_type, tel_ids=None):\n+       \n+        if not tel_ids:\n+            if tel_type not in self.telescopes:\n+                raise ValueError(\"Selected tel type {} not found in dataset.\".format(tel_type))\n+            elif tel_type not in self._image_mapper.mapping_tables:\n+                raise NotImplementedError(\"Mapping table for selected tel type {} not implemented.\".format(tel_type))\n+            else:\n+                self.selected_telescope_type = tel_type\n+                self.selected_telescopes = self.telescopes[tel_type]\n+        else:\n+            self.selected_telescopes = []\n+            all_tel_ids = {}\n+            for tel_type in self.telescopes:\n+                for tel_id in self.telescopes[tel_type]:\n+                    all_tel_ids[tel_id] = tel_type\n+            if len(set([all_tel_ids[tel_id] for tel_id in tel_ids])) > 1:\n+                raise ValueError(\"Cannot select telescopes of multiple types.\")\n+            for tel_id in tel_ids:\n+                if all_tel_ids[tel_id] != tel_type:\n+                    raise ValueError(\"Selected tel id {} is of wrong tel type {}.\".format(tel_id, all_tel_ids[tel_id]))\n+                elif tel_id not in all_tel_ids:\n+                    raise ValueError(\"Selected tel id {} not found in dataset.\".format(tel_id))\n+                elif all_tel_ids[tel_id] not in self._image_mapper.mapping_tables:\n+                    raise NotImplementedError(\n+                            \"Mapping table for tel type {} of selected tel id {} not implemented.\".format(\n+                                all_tel_ids[tel_id],tel_id))\n+                else:\n+                    self.selected_telescopes.append(tel_id)\n+            self.selected_telescope_type = tel_type\n+  \n+    # Get a single telescope image from a particular event, \n+    # uniquely identified by a tuple (run_number, event_number, tel_id).\n+    # The raw 1D trace is transformed into a 1-channel 2D image using a\n+    # mapping table but no other processing is done.\n+    def get_image(self, run_number, event_number, tel_id):\n+        \n+        tel_type, _ = self.__tel_id_to_type_index[tel_id]\n+        if tel_type not in self._image_mapper.mapping_tables:\n+            raise ValueError(\"Requested image from tel_type {} without valid mapping table.\".format(tel_type))\n+\n+        # get filename, image table name (telescope type), and index\n+        # corresponding to the desired image\n+        filename, tel_type, index = self.__single_tel_examples_to_indices[(run_number, event_number, tel_id)]\n+        \n+        f = self.files[filename]\n+        record = f.root._f_get_child(tel_type)[index]\n+        \n+        # Allocate empty numpy array of shape (len_trace + 1,) to hold trace plus\n+        # \"empty\" pixel at index 0 (used to fill blank areas in image)\n+        trace = np.empty(shape=(record['image_charge'].shape[0] + 1),dtype=np.float32)\n+        # Read in the trace from the record \n+        trace[0] = 0.0\n+        trace[1:] = record['image_charge']\n+        trace = np.expand_dims(trace, axis=1)\n+\n+        # Create image by indexing into the trace using the mapping table, then adding a\n+        # dimension to given shape (length,width,1)\n+        image = self._image_mapper.map_image(trace, tel_type)\n+\n+        return image\n+\n+    def get_example(self, *identifiers):\n+\n+        if self.example_type == \"single_tel\":\n+\n+            run_number, event_number, tel_id = identifiers\n+\n+            # get image from image table\n+            image = self.get_image(run_number, event_number, tel_id) \n+\n+            # locate corresponding event record to get particle type\n+            filename, index = self.__events_to_indices[(run_number, event_number)]\n+            f = self.get_file_handle(filename)\n+            event_record = f.root.Event_Info[index]\n+\n+            # Get classification label by converting CORSIKA particle code\n+            label = self.ids_to_labels[event_record['particle_id']] \n+            \n+            data = [image]\n+            labels = [label]\n+\n+        elif self.example_type == \"array\":\n+\n+            run_number, event_number = identifiers\n+            tel_type = self.selected_telescope_type\n+\n+            # get filename, image table name (telescope type), and index\n+            # corresponding to the desired image\n+            filename, index = self.__events_to_indices[(run_number, event_number)]\n+            \n+            f = self.files[filename]\n+            record = f.root.Event_Info[index]\n+\n+            # Get classification label by converting CORSIKA particle code\n+            label = self.ids_to_labels[record['particle_id']] \n+          \n+            # Collect images and binary trigger values only for telescopes\n+            # in selected_telescopes            \n+            images = []\n+            triggers = []\n+            aux_inputs = []\n+            image_shape = self._image_mapper.image_shapes[tel_type] \n+            for tel_id in self.selected_telescopes:\n+                _, index = self.__tel_id_to_type_index[tel_id]\n+                i = record[tel_type + \"_indices\"][index]\n+                if i == 0:\n+                    # Telescope did not trigger. Its outputs will be dropped\n+                    # out, so input is arbitrary. Use an empty array for\n+                    # efficiency.\n+                    images.append(np.empty(image_shape))\n+                    triggers.append(0)  \n+                else:\n+                    image = self.get_image(run_number, event_number, tel_id) \n+                    images.append(image)\n+                    triggers.append(1)\n+                if self.use_telescope_positions:\n+                    telescope_position = self.telescope_positions[tel_type][tel_id]\n+                    telescope_position = [float(telescope_position[i]) / self.max_telescope_position[i] \n+                            for i in range(self.num_position_coordinates)]\n+                    aux_inputs.append(telescope_position)\n+            \n+            data = [images, triggers, aux_inputs]\n+            labels = [label]\n+\n+        if self.data_processor:\n+            data, labels = self.data_processor.process_example(data, labels, self.selected_telescope_type)\n+\n+        if self.example_type == 'single_tel':\n+            data[0] = np.stack(data[0]).astype(np.float32)\n+        elif self.example_type == 'array':\n+            data[0] = np.stack(data[0]).astype(np.float32)\n+            data[1] = np.array(data[1], dtype=np.int8)\n+            data[2] = np.array(data[2], dtype=np.float32)\n+\n+        return data + labels\n+\n+    # Function to get all indices in each HDF5 file which pass a provided cut condition\n+    # For single tel mode, returns all MSTS image table indices from events passing the cuts\n+    # For array-level mode, returns all event table indices from events passing the cuts\n+    # Cut condition must be a string formatted as a Pytables selection condition\n+    # (i.e. for table.where()). See Pytables documentation for examples.\n+    # If cut condition is empty, do not apply any cuts.\n+\n+    # Min num tels is a dictionary specifying the minimum number of telescopes of each type required\n+    def _apply_cuts(self):\n+\n+        passing_examples = []\n+        self.passing_num_examples_by_particle_id = {}\n+\n+        for filename in self.files:\n+            f = self.files[filename]\n+            \n+            particle_id = f.root._v_attrs.particle_type\n+            if particle_id not in self.passing_num_examples_by_particle_id:\n+                self.passing_num_examples_by_particle_id[particle_id] = 0\n+    \n+            event_table = f.root.Event_Info\n+            rows = [row for row in event_table.where(self.cut_condition)] if self.cut_condition else event_table.iterrows()\n+            for row in rows:\n+                # First check if min num tels cut is passed\n+                if np.count_nonzero(row[self.selected_telescope_type + \"_indices\"]) < self.min_num_tels:\n+                    pass\n+               \n+                # If example_type is single_tel, there will \n+                # be only a single selected telescope type\n+                if self.example_type == \"single_tel\":\n+                    image_indices = row[self.selected_tel_type + \"_indices\"]\n+                    for tel_id in self.selected_telescopes:\n+                        _, index = self.__tel_id_to_type_index[tel_id]\n+                        if image_indices[index] != 0:\n+                            passing_examples.append((row[\"run_number\"], row[\"event_number\"], tel_id))\n+                            self.passing_num_examples_by_particle_id[particle_id] += 1\n+                # if example type is \n+                elif self.example_type == \"array\":                               \n+                    passing_examples.append((row[\"run_number\"], row[\"event_number\"]))\n+                    self.passing_num_examples_by_particle_id[particle_id] += 1\n+\n+        # get total number of examples\n+        num_examples = 0\n+        for particle_id in self.passing_num_examples_by_particle_id:\n+            num_examples += self.passing_num_examples_by_particle_id[particle_id]\n+\n+        # compute class weights\n+        self.class_weights = []\n+        for particle_id in sorted(self.passing_num_examples_by_particle_id, key=lambda x: self.ids_to_labels[x]):\n+            self.class_weights.append(num_examples/float(self.passing_num_examples_by_particle_id[particle_id]))\n+\n+        # divide passing events into training and validation sets\n+\n+        # use random seed to get reproducible training\n+        # and validation sets\n+        if self.seed is not None:\n+            random.seed(self.seed)\n+\n+        random.shuffle(passing_examples)\n+\n+        if self.mode == 'train':\n+            # Split examples into training and validation sets\n+            num_validation = math.ceil(self.validation_split * len(passing_examples)) \n+           \n+            self.training_examples = passing_examples[num_validation:len(passing_examples)]\n+            self.validation_examples = passing_examples[0:num_validation]\n+\n+        elif self.mode == 'test':\n+\n+            self.examples = passing_examples\n+\n+    # Given a list of examples (tuples), returns a generator function \n+    # which yields from the list. Optionally shuffles the examples\n+    @staticmethod\n+    def _get_generator_function(examples_list, shuffle=True):\n+\n+        def generator_fn():\n+            if shuffle:\n+                random.shuffle(examples_list)\n+            for example in examples_list:\n+                yield example\n+\n+        return generator_fn\n+\n+    def get_example_generators(self):\n+\n+        if self.mode == \"train\":\n+            # Convert lists of training and validation examples into generators\n+            training_generator_fn = self._get_generator_function(self.training_examples)\n+            validation_generator_fn = self._get_generator_function(self.validation_examples)\n+\n+            return training_generator_fn, validation_generator_fn, self.class_weights\n+        \n+        elif self.mode == \"test\":\n+\n+            test_generator_fn = self._get_generator_function(self.examples)\n+\n+            return test_generator_fn, self.class_weights\n+\n+# given a dictionary of form {particle_id: num_examples}\n+# logs an informative message about the proportions belonging\n+# to different particle ids.\n+def log_class_breakdown(num_by_particle_id, logger=None):\n+\n+    if not logger: logger = logging.get_logger()\n+\n+    total_num = sum(num_by_particle_id.values())\n+    logger.info(\"%d total.\", total_num)\n+    for particle_id in num_by_particle_id:\n+        logger.info(\"%d: %d (%f%%)\",\n+                particle_id, \n+                num_by_particle_id[particle_id], \n+                100 * float(num_by_particle_id[particle_id])/total_num)\n+\ndiff --git a/ctalearn/data_processing.py b/ctalearn/data_processing.py\nnew file mode 100644\n--- /dev/null\n+++ b/ctalearn/data_processing.py\n@@ -0,0 +1,225 @@\n+import numpy as np\n+import cv2\n+from operator import itemgetter\n+\n+from ctalearn.image_mapping import ImageMapper\n+\n+class DataProcessor():\n+\n+    def __init__(self,\n+            image_mapper=ImageMapper(None),\n+            crop=True,\n+            bounding_box_sizes={'MSTS': 48},\n+            image_cleaning=\"twolevel\",\n+            thresholds={'MSTS': (5.5, 1.0)},\n+            return_cleaned_images=False,\n+            normalization=\"log\",\n+            sort_images_by=None,\n+            num_shower_coordinates=2,\n+            image_charge_mins=None\n+            ):\n+        \n+        self._image_mapper = image_mapper\n+\n+        self.crop = crop\n+        self.bounding_box_sizes = bounding_box_sizes\n+        self.image_cleaning = image_cleaning\n+        self.thresholds = thresholds\n+        self.return_cleaned_images = return_cleaned_images\n+\n+        self.normalization = normalization\n+        self.image_charge_mins= image_charge_mins\n+\n+        self.sort_images_by = sort_images_by\n+\n+        self.image_shapes = {}\n+        for tel_type in self._image_mapper.image_shapes:\n+            if self.crop and tel_type in self.bounding_box_sizes:\n+                self.image_shapes[tel_type]= [self.bounding_box_sizes[tel_type], \n+                    self.bounding_box_sizes[tel_type], \n+                    self._image_mapper.image_shapes[tel_type][2]]\n+            else:\n+                self.image_shapes[tel_type] = self._image_mapper.image_shapes[tel_type]\n+\n+        self.num_additional_aux_params = 0 \n+        self.num_additional_aux_params += num_shower_coordinates \n+\n+    # Crop an image about the shower center, optionally applying image cleaning\n+    # to obtain a better fit. The shower centroid is calculated as the mean of\n+    # pixel positions weighted by the charge, after cleaning. The cropped image is\n+    # obtained as a square bounding box centered on the centroid of side length\n+    # bounding_box_size.\n+    def _crop_image(self, image, tel_type):\n+\n+        if self.image_cleaning == \"none\":\n+            cleaned_image = image\n+        elif self.image_cleaning  == \"twolevel\":\n+            # Apply two-level cleaning to isolate the shower. First, filter for\n+            # shower pixels by applying a high charge cut (picture threshold).\n+            # Next, retain weaker pixels at the shower edge by allowing pixels\n+            # adjacent to those passing the first cut to pass a weaker cut\n+            # (boundary threshold).\n+            \n+            # Get only the first channel (charge) of an image of arbitrary depth\n+            image_charge = image[:,:,0]\n+\n+            # Apply picture threshold to charge image to get mask\n+            m = (image_charge > self.thresholds[tel_type][0]).astype(np.uint8)\n+            # Dilate the mask once to add all adjacent pixels (i.e. kernel is 3x3)\n+            kernel = np.ones((3,3), np.uint8) \n+            m = cv2.dilate(m, kernel)\n+            # Apply boundary threshold to keep weaker but adjacent pixels\n+            m = (m * image_charge > self.thresholds[tel_type][1]).astype(np.uint8)\n+            m = np.expand_dims(m, 2)\n+\n+            # Multiply by the mask to get the cleaned image\n+            cleaned_image = image * m\n+        else:\n+            raise ValueError('Unrecognized image cleaning method: {}'.format(\n+                image_cleaning_method))\n+\n+        # compute image moments, then use them to compute the centroid\n+        # coordinates (x_0, y_0)\n+        # NOTE: x_0 refers to a coordinate value along array axis 0 (rows, top to bottom)\n+        # y_0 refers to a coordinate value along array axis 1 (columns, left to right)\n+        # NOTE: when the image is blank after cleaning (sum of pixels is 0), set the\n+        # centroid to center of image to avoid divide by zero errors\n+        moments = cv2.moments(cleaned_image[:,:,0])\n+        x_0 = moments['m01']/moments['m00'] if moments['m00'] != 0 else image.shape[1]/2\n+        y_0 = moments['m10']/moments['m00'] if moments['m00'] != 0 else image.shape[0]/2\n+\n+        # compute min and max x and y indices (along axis 0 and axis 1 respectively)\n+        # NOTE: these values are rounded and cast to integers, so they are valid indices\n+        # into the array\n+        # NOTE: rounding (and subtracting one from the max values) ensures that for all\n+        # float values of x_0, y_0, the values of indices x_min, x_max, y_min, y_max mark \n+        # a bounding box of exactly shape (BOUNDING_BOX_SIZE, BOUNDING_BOX_SIZE)\n+        bounding_box_size = self.bounding_box_sizes[tel_type]\n+        x_min = int(round(x_0 - bounding_box_size/2))\n+        x_max = int(round(x_0 + bounding_box_size/2)) - 1\n+        y_min = int(round(y_0 - bounding_box_size/2))\n+        y_max = int(round(y_0 + bounding_box_size/2)) - 1\n+\n+        cropped_image = np.zeros((bounding_box_size,bounding_box_size,image.shape[2]),dtype=np.float32)\n+\n+        # indices into the original image array which correspond to the bounding box region\n+        # when the bounding box goes over the edge of the original image array,\n+        # we truncate the appropriate indices so that all of x_min_image, x_max_image, etc.\n+        # are valid indices into the array\n+        x_min_image = x_min if x_min >= 0 else 0\n+        x_max_image = x_max if x_max <= (image.shape[0] - 1) else (image.shape[0] -1)\n+        y_min_image = y_min if y_min >= 0 else 0\n+        y_max_image = y_max if y_max <= (image.shape[1] - 1) else (image.shape[1] -1)\n+\n+        # indices into the cropped image array of shape (BOUNDING_BOX_SIZE,BOUNDING_BOX_SIZE,image.shape[2])\n+        # which correspond to the region described by x_min, x_max, etc. in the original\n+        # image array. The region of the cropped image array which does not correspond to valid \n+        # positions in the original image (the part which goes over the edges) are left filled\n+        # with zeros as padding.\n+        x_min_cropped = -x_min if x_min < 0 else 0\n+        x_max_cropped = (bounding_box_size - (x_max - x_max_image) - 1) if x_max >= (image.shape[0] - 1) else bounding_box_size - 1\n+        y_min_cropped = -y_min if y_min < 0 else 0\n+        y_max_cropped = (bounding_box_size - (y_max - y_max_image) - 1) if y_max >= (image.shape[1] - 1) else bounding_box_size - 1\n+\n+        # transfer the cropped portion of the image array into the smaller, padded cropped_image array.\n+        # Use either the cleaned or uncleaned image as specified\n+        returned_image = (cleaned_image if self.return_cleaned_images else image)\n+        cropped_image[x_min_cropped:x_max_cropped+1,y_min_cropped:y_max_cropped+1,:] = returned_image[x_min_image:x_max_image+1,y_min_image:y_max_image+1,:]\n+\n+        return cropped_image, x_0, y_0\n+\n+    # Normalize the first channel of a given image\n+    # with the selected method\n+    def _normalize_image(self, image, tel_type):\n+\n+        if self.normalization == \"log\":\n+            image[:,:,0] = np.log(image[:,:,0] - self.image_charge_mins[tel_type] + 1.0)\n+        else:\n+            raise ValueError(\"Unrecognized normalization method {} selected.\".format(self.normalization))\n+\n+        return image\n+\n+    # Function to apply all selected processing steps\n+    # on a given image. Returns the processed image and a\n+    # list of additional auxiliary parameters produced by\n+    # the processing.\n+    def _process_image(self, image, tel_type):\n+        auxiliary_info = []\n+        if self.crop:\n+            image, *shower_position = self._crop_image(image, tel_type)\n+            normalized_shower_position = [float(i)/self._image_mapper.image_shapes[tel_type][0] for i in shower_position] \n+            auxiliary_info.extend(normalized_shower_position)\n+        if self.normalization:\n+            image = self._normalize_image(image, tel_type)\n+\n+        return image, auxiliary_info\n+\n+    def process_example(self, data, label, tel_type):\n+        \n+        # infer whether example is single tel or array based on\n+        # number of elements in data\n+        if len(data) == 1:\n+            example_type = \"single_tel\"\n+        else:\n+            example_type = \"array\"\n+\n+        if example_type == \"single_tel\":\n+            image = data[0]\n+\n+            image, _ = self._process_image(image, tel_type)\n+            data = [image]\n+            \n+            return [data, label]\n+        \n+        elif example_type == \"array\":\n+            images = data[0]\n+            triggers = data[1]\n+            aux_inputs = data[2]\n+            \n+            image_shape = self.image_shapes[tel_type]\n+            for i in range(len(images)):\n+                trigger = triggers[i]\n+                if trigger == 0:\n+                    # telescope did not trigger, so provide a\n+                    # zeroed-out image\n+                    images[i] = np.zeros(image_shape)\n+                    if self.crop:\n+                        # add dummy centroid position to aux info\n+                        aux_inputs[i].extend([0.0, 0.0])\n+                else:\n+                    image, auxiliary_info = self._process_image(images[i], tel_type)\n+                    images[i] = image\n+                    aux_inputs[i].extend(auxiliary_info)\n+      \n+            if self.sort_images_by == \"trigger\":\n+                # Sort the images, triggers, and grouped auxiliary inputs by\n+                # trigger, listing the triggered telescopes first\n+                images, triggers, aux_inputs = map(list,\n+                        zip(*sorted(zip(images, triggers, aux_inputs), reverse=True, key=itemgetter(1))))\n+            elif self.sort_images_by == \"size\":\n+                # Sort images by size (sum of charge in all pixels) from largest to smallest\n+                images, triggers, aux_inputs = map(list,\n+                        zip(*sorted(zip(images, triggers, aux_inputs), reverse=True, key=lambda x: np.sum(x[0]))))\n+            \n+            data = [images, triggers, aux_inputs]\n+\n+            return [data, label]\n+\n+    def get_metadata(self):\n+        \n+        metadata = {\n+                'processed_image_shapes': self.image_shapes,\n+                'num_additional_aux_params': self.num_additional_aux_params\n+                }\n+\n+        return metadata\n+\n+    # TODO: implement data augmentation.\n+    # Should be done at random each time an example is\n+    # processed, as the list of examples is fixed and determined\n+    # by DataLoader\n+    def _augment_data(self):\n+        raise NotImplementedError        \n+ \n+\n+\ndiff --git a/ctalearn/image.py b/ctalearn/image.py\ndeleted file mode 100644\n--- a/ctalearn/image.py\n+++ /dev/null\n@@ -1,58 +0,0 @@\n-import numpy as np\n-\n-IMAGE_SHAPES = {\n-        'MSTS': (120,120,1)\n-        }\n-\n-def generate_table_MSTS():\n-    \"\"\"\n-    Function returning MSTS mapping table (used to index into the trace when converting from trace to image).\n-    \"\"\"\n-    \n-    ROWS = 15\n-    MODULE_DIM = 8\n-    MODULES_PER_ROW = [\n-        5,\n-        9,\n-        11,\n-        13,\n-        13,\n-        15,\n-        15,\n-        15,\n-        15,\n-        15,\n-        13,\n-        13,\n-        11,\n-        9,\n-        5]\n-    \n-    # bottom left corner of each 8 x 8 module in the camera\n-    # counting from the bottom row, left to right\n-    MODULE_START_POSITIONS = [(((IMAGE_SHAPES['MSTS'][0] - MODULES_PER_ROW[j] *\n-                                 MODULE_DIM) / 2) +\n-                               (MODULE_DIM * i), j * MODULE_DIM)\n-                              for j in range(ROWS)\n-                              for i in range(MODULES_PER_ROW[j])]\n-\n-    table = np.zeros(shape=(IMAGE_SHAPES['MSTS'][0],IMAGE_SHAPES['MSTS'][1]),dtype=int)   \n-    # Fill appropriate positions with indices\n-    # NOTE: we append a 0 entry to the (11328,) trace array to allow us to use fancy indexing to fill\n-    # the empty areas of the (120,120) image. Accordingly, all indices in the mapping table are increased by 1\n-    # (j starts at 1 rather than 0)\n-    j = 1\n-    for (x_0,y_0) in MODULE_START_POSITIONS:\n-        for i in range(MODULE_DIM * MODULE_DIM):\n-            x = int(x_0 + i // MODULE_DIM)\n-            y = y_0 + i % MODULE_DIM\n-            table[x][y] = j\n-            j += 1\n-\n-    return table\n-\n-MAPPING_TABLES = {\n-        'MSTS': generate_table_MSTS()\n-        }\n-\n-\ndiff --git a/ctalearn/image_mapping.py b/ctalearn/image_mapping.py\nnew file mode 100644\n--- /dev/null\n+++ b/ctalearn/image_mapping.py\n@@ -0,0 +1,460 @@\n+import numpy as np\n+import logging\n+import threading\n+\n+from scipy.sparse import csr_matrix\n+\n+logger = logging.getLogger(__name__)\n+\n+# Multithread-safe PyTables open and close file functions\n+# See http://www.pytables.org/latest/cookbook/threading.html\n+lock = threading.Lock()\n+\n+\n+class ImageMapper():\n+    def __init__(self,\n+            image_shapes=None):\n+        \"\"\"   \n+        :param image_mapping_settings: (Hex converter algorithm, output image shape image_shapes, ...)\n+        \"\"\"\n+        if image_shapes is not None:\n+            self.image_shapes = image_mapping_settings['image_shapes']\n+        else:\n+            self.image_shapes = {\n+                    'MSTS': (120, 120, 1),\n+                    'VTS': (54, 54, 1),\n+                    'MSTF': (120, 120, 1),\n+                    'MSTN': (120, 120, 1),\n+                    'LST': (120, 120, 1),\n+                    'SST1': (100, 100, 1),\n+                    'SSTC': (48, 48, 1),\n+                    'SSTA': (56, 56, 1)\n+                    }\n+\n+        self.pixel_lengths = {\n+                'LST': 0.05,\n+                'MSTF': 0.05,\n+                'MSTN': 0.05,\n+                'MSTS': 0.00669,\n+                'SST1': 0.0236,\n+                'SSTC':0.0064,\n+                'SSTA':0.0071638,\n+                'VTS': 1.0 / np.sqrt(2)\n+                }\n+\n+        self.pixel_positions = {tel_type:self.__read_pix_pos_files(tel_type) for tel_type in self.pixel_lengths if tel_type != 'VTS'}\n+\n+        self.num_pixels = {\n+                'MSTF': 1764,\n+                'MSTN': 1855,\n+                'SST1': 1296,\n+                'LST': 1855,\n+                'MSTS': 11328,\n+                'SSTC': 2048,\n+                'SSTA': 2368,\n+                'VTS': 499\n+                }\n+\n+        self.mapping_tables = {\n+            'MSTS': self.generate_table_MSTS(),\n+            'VTS': self.generate_table_VTS(),\n+            'MSTF': self.generate_table_generic('MSTF'),\n+            'MSTN': self.generate_table_generic('MSTN'),\n+            'LST': self.generate_table_generic('LST'),\n+            'SST1': self.generate_table_generic('SST1'),\n+            'SSTC': self.generate_table_SSTC(),\n+            'SSTA': self.generate_table_SSTA()\n+            }\n+\n+    def map_image(self, pixels, telescope_type):\n+        \"\"\"\n+        :param pixels: a numpy array of values for each pixel, in order of pixel index.\n+                       The array has dimensions [N_pixels, N_channels] where N_channels is e.g., \n+                       1 when just using charges and 2 when using charges and peak arrival times. \n+        :param telescope_type: a string specifying the telescope type as defined in the HDF5 format, \n+                        e.g., 'MSTS' for SCT data, which is the only currently implemented telescope type.\n+        :return: \n+        \"\"\"\n+        if telescope_type in self.image_shapes.keys():\n+            self.telescope_type = telescope_type\n+        else:\n+            raise ValueError('Sorry! Telescope type {} isn\\'t supported.'.format(telescope_type))\n+\n+        if telescope_type == \"MSTS\":\n+            telescope_image = pixels[self.mapping_tables[telescope_type]]\n+        elif telescope_type in ['LST', 'MSTF', 'MSTN', 'SST1', 'SSTC', 'SSTA', 'VTS']:\n+            telescope_image = (pixels.T @ self.mapping_tables[telescope_type]).reshape(self.image_shapes[telescope_type][0],\n+                                                                                       self.image_shapes[telescope_type][1], 1)\n+        \n+        return telescope_image\n+\n+\n+    def generate_table_VTS(self):\n+        \"\"\"\n+        Function returning VTS mapping matrix (used to convert a 1d trace to a resampled 2d image in square lattice).\n+        Note that for a VERITAS telescope, input trace is of shape (499), while output image is of shape (54, 54, 1)\n+        The return matrix is of shape (499+1, 54*54) = (500, 2916)\n+                                      # the added 1 is for the 0th channel = 0 for padding\n+        To get the image from trace using the return matrix, \n+        do: (trace.T @ mapping_matrix3d_sparse).reshape(54,54,1)\n+        \"\"\"\n+        # telescope hardcoded values\n+        num_pixels = 499\n+        pixel_side_len = self.pixel_lengths['VTS']\n+        num_spirals = 13\n+\n+        pixel_weight = 1.0/4 #divide each pixel intensity into 4 sub pixels\n+        \n+        pos = np.zeros((num_pixels, 2), dtype=float)\n+        delta_x = pixel_side_len * np.sqrt(2) / 2.\n+        delta_y = pixel_side_len * np.sqrt(2)\n+        \n+        pixel_index = 1\n+\n+        # return mapping_matrix (54, 54)\n+        # leave 0 for padding, mapping matrix from 1 to 499\n+        mapping_matrix = np.zeros((num_pixels + 1, self.image_shapes['VTS'][0], self.image_shapes['VTS'][1]), dtype=float)\n+\n+        for i in range(1, num_spirals + 1):\n+            x = 2.0 * i * delta_x\n+            y = 0.0\n+\n+            # For the two outermost spirals, there is not a pixel in the y=0 row.\n+            if i < 12:\n+                pixel_index += 1\n+               \n+                pos[pixel_index - 1, 0] = x\n+                pos[pixel_index - 1, 1] = y\n+\n+            next_pix_dir = np.zeros((i * 6, 2))\n+            skip_pixel = np.zeros((i * 6, 1))\n+\n+            for j in range(i * 6 - 1):\n+                if (j / i < 1):\n+                    next_pix_dir[j, :] = [-1, -1]\n+                elif (j / i >= 1 and j / i < 2):\n+                    next_pix_dir[j, :] = [-2, 0]\n+                elif (j / i >= 2 and j / i < 3):\n+                    next_pix_dir[j, :] = [-1, 1]\n+                elif (j / i >= 3 and j / i < 4):\n+                    next_pix_dir[j, :] = [1, 1]\n+                elif (j / i >= 4 and j / i < 5):\n+                    next_pix_dir[j, :] = [2, 0]\n+                elif (j / i >= 5 and j / i < 6):\n+                    next_pix_dir[j, :] = [1, -1]\n+\n+            # The two outer spirals are not fully populated with pixels.\n+            # The second outermost spiral is missing only six pixels (one was excluded above).\n+            if (i == 12):\n+                for k in range(1, 6):\n+                    skip_pixel[i * k - 1] = 1\n+            # The outmost spiral only has a total of 36 pixels.  We need to skip over the\n+            # place holders for the rest.\n+            if (i == 13):\n+                skip_pixel[0:3] = 1\n+                skip_pixel[9:16] = 1\n+                skip_pixel[22:29] = 1\n+                skip_pixel[35:42] = 1\n+                skip_pixel[48:55] = 1\n+                skip_pixel[61:68] = 1\n+                skip_pixel[74:77] = 1\n+\n+            for j in range(i * 6 - 1):\n+\n+                x += next_pix_dir[j, 0] * delta_x\n+                y += next_pix_dir[j, 1] * delta_y\n+\n+                if skip_pixel[j, 0] == 0:\n+                    pixel_index += 1\n+                    pos[pixel_index - 1, 0] = x\n+                    pos[pixel_index - 1, 1] = y\n+\n+        pos_shifted = pos + 26 + pixel_side_len / 2.0\n+        for i in range(num_pixels):\n+            x, y = pos_shifted[i, :]\n+            x_L = int(round(x + pixel_side_len / 2.0))\n+            x_S = int(round(x - pixel_side_len / 2.0))\n+            y_L = int(round(y + pixel_side_len / 2.0))\n+            y_S = int(round(y - pixel_side_len / 2.0))\n+            \n+            # leave 0 for padding, mapping matrix from 1 to 499\n+            mapping_matrix[i + 1, x_S:x_L + 1, y_S:y_L + 1] = pixel_weight\n+\n+        mapping_matrix = csr_matrix(mapping_matrix.reshape(num_pixels + 1, self.image_shapes['VTS'][0] * self.image_shapes['VTS'][1]))        \n+        \n+        return mapping_matrix\n+\n+    def generate_table_MSTS(self):\n+        \"\"\"\n+        Function returning MSTS mapping table (used to index into the trace when converting from trace to image).\n+        \"\"\"\n+\n+        ROWS = 15\n+        MODULE_DIM = 8\n+        MODULES_PER_ROW = [\n+            5,\n+            9,\n+            11,\n+            13,\n+            13,\n+            15,\n+            15,\n+            15,\n+            15,\n+            15,\n+            13,\n+            13,\n+            11,\n+            9,\n+            5]\n+\n+        # bottom left corner of each 8 x 8 module in the camera\n+        # counting from the bottom row, left to right\n+        MODULE_START_POSITIONS = [(((self.image_shapes['MSTS'][0] - MODULES_PER_ROW[j] *\n+                                     MODULE_DIM) / 2) +\n+                                   (MODULE_DIM * i), j * MODULE_DIM)\n+                                  for j in range(ROWS)\n+                                  for i in range(MODULES_PER_ROW[j])]\n+\n+        table = np.zeros(shape=(self.image_shapes['MSTS'][0], self.image_shapes['MSTS'][1]), dtype=int)\n+        # Fill appropriate positions with indices\n+        # NOTE: we append a 0 entry to the (11328,) trace array to allow us to use fancy indexing to fill\n+        # the empty areas of the (120,120) image. Accordingly, all indices in the mapping table are increased by 1\n+        # (j starts at 1 rather than 0)\n+        j = 1\n+        for (x_0, y_0) in MODULE_START_POSITIONS:\n+            for i in range(MODULE_DIM * MODULE_DIM):\n+                x = int(x_0 + i // MODULE_DIM)\n+                y = y_0 + i % MODULE_DIM\n+                table[x][y] = j\n+                j += 1\n+\n+        return table\n+\n+    def generate_table_SSTC(self):\n+        \"\"\"\n+        Function returning SSTC mapping table (used to index into the trace when converting from trace to image).\n+        \"\"\"\n+\n+        MODULES_PER_ROW_DICT = { 0: 32,\n+                                 1: 32,\n+                                 2: 32,\n+                                 3: 32,\n+                                 4: 32,\n+                                 5: 32,\n+                                 6: 32,\n+                                 7: 32,\n+                                 8: 48,\n+                                 9: 48,\n+                                 10: 48,\n+                                 11: 48,\n+                                 12: 48,\n+                                 13: 48,\n+                                 14: 48,\n+                                 15: 48,\n+                                 16: 48,\n+                                 17: 48,\n+                                 18: 48,\n+                                 19: 48,\n+                                 20: 48,\n+                                 21: 48,\n+                                 22: 48,\n+                                 23: 48,\n+                                 24: 48,\n+                                 25: 48,\n+                                 26: 48,\n+                                 27: 48,\n+                                 28: 48,\n+                                 29: 48,\n+                                 30: 48,\n+                                 31: 48,\n+                                 32: 48,\n+                                 33: 48,\n+                                 34: 48,\n+                                 35: 48,\n+                                 36: 48,\n+                                 37: 48,\n+                                 38: 48,\n+                                 39: 48,\n+                                 40: 32,\n+                                 41: 32,\n+                                 42: 32,\n+                                 43: 32,\n+                                 44: 32,\n+                                 45: 32,\n+                                 46: 32,\n+                                 47: 32 }\n+\n+        # This is set to int because no oversampling is done\n+        mapping_matrix3d = np.zeros((self.num_pixels['SSTC'] + 1,\n+                                     self.image_shapes['SSTC'][0],\n+                                     self.image_shapes['SSTC'][1]), dtype=int)\n+\n+        i = 0  # Pixel count\n+        for row_, n_per_row_ in MODULES_PER_ROW_DICT.items():\n+            row_start_ = int((self.image_shapes['SSTC'][1] - n_per_row_) / 2)\n+            for j in range(n_per_row_):\n+                x, y = (row_, j + row_start_)\n+                mapping_matrix3d[i + 1, x, y] = 1\n+                i += 1\n+\n+        sparse_map_mat = csr_matrix(mapping_matrix3d.reshape(self.num_pixels['SSTC'] + 1,\n+                                                             self.image_shapes['SSTC'][0]*\n+                                                             self.image_shapes['SSTC'][1]))\n+\n+        return sparse_map_mat\n+\n+\n+    def generate_table_SSTA(self):\n+        \"\"\"\n+        Function returning SSTA mapping table (used to index into the trace when converting from trace to image).\n+        \"\"\"\n+        MODULES_PER_ROW_DICT = { 0: 24,\n+                                 1: 24,\n+                                 2: 24,\n+                                 3: 24,\n+                                 4: 24,\n+                                 5: 24,\n+                                 6: 24,\n+                                 7: 24,\n+                                 8: 40,\n+                                 9: 40,\n+                                 10: 40,\n+                                 11: 40,\n+                                 12: 40,\n+                                 13: 40,\n+                                 14: 40,\n+                                 15: 40,\n+                                 16: 56,\n+                                 17: 56,\n+                                 18: 56,\n+                                 19: 56,\n+                                 20: 56,\n+                                 21: 56,\n+                                 22: 56,\n+                                 23: 56,\n+                                 24: 56,\n+                                 25: 56,\n+                                 26: 56,\n+                                 27: 56,\n+                                 28: 56,\n+                                 29: 56,\n+                                 30: 56,\n+                                 31: 56,\n+                                 32: 56,\n+                                 33: 56,\n+                                 34: 56,\n+                                 35: 56,\n+                                 36: 56,\n+                                 37: 56,\n+                                 38: 56,\n+                                 39: 56,\n+                                 40: 40,\n+                                 41: 40,\n+                                 42: 40,\n+                                 43: 40,\n+                                 44: 40,\n+                                 45: 40,\n+                                 46: 40,\n+                                 47: 40,\n+                                 48: 24,\n+                                 49: 24,\n+                                 50: 24,\n+                                 51: 24,\n+                                 52: 24,\n+                                 53: 24,\n+                                 54: 24,\n+                                 55: 24}\n+        # This is set to int because no oversampling is done\n+        mapping_matrix3d = np.zeros((self.num_pixels['SSTA'] + 1,\n+                                     self.image_shapes['SSTA'][0],\n+                                     self.image_shapes['SSTA'][1]), dtype=int)\n+\n+        i = 0  # Pixel count\n+        for row_, n_per_row_ in MODULES_PER_ROW_DICT.items():\n+            row_start_ = int((self.image_shapes['SSTA'][1] - n_per_row_) / 2)\n+            for j in range(n_per_row_):\n+                x, y = (row_, j + row_start_)\n+                mapping_matrix3d[i + 1, x, y] = 1\n+                i = i + 1\n+\n+        sparse_map_mat = csr_matrix(mapping_matrix3d.reshape(self.num_pixels['SSTA'] + 1,\n+                                                             self.image_shapes['SSTA'][0]*\n+                                                             self.image_shapes['SSTA'][1]))\n+\n+        return sparse_map_mat\n+\n+    def generate_table_generic(self, tel_type, pixel_weight=1.0/4):\n+        # Get telescope pixel positions for the given tel type\n+        pos = self.pixel_positions[tel_type]\n+\n+        # Get relevant parameters\n+        output_dim = self.image_shapes[tel_type][0]\n+        num_pixels = self.num_pixels[tel_type]\n+        pixel_length = self.pixel_lengths[tel_type]\n+\n+        # For LST and MSTN cameras, rotate by a fixed amount to\n+        # align for oversampling\n+        if tel_type in [\"LST\", \"MSTN\"]:\n+            pos = self.rotate_cam(pos)\n+\n+        # Compute mapping matrix\n+        pos_int = pos / pixel_length * 2 + 1\n+        pos_int[0, :] = pos_int[0, :] / np.sqrt(3) * 2\n+        pos_int[0, :] -= np.min(pos_int[0, :])\n+        pos_int[1, :] -= np.min(pos_int[1, :])\n+\n+        mapping_matrix = np.zeros((num_pixels + 1, output_dim, output_dim), dtype=float)\n+        \n+        for i in range(num_pixels):\n+            x, y = pos_int[:, i]\n+            x_S = int(round(x))\n+            x_L = x_S + 1\n+            y_S = int(round(y))\n+            y_L = y_S + 1\n+            # leave 0 for padding, mapping matrix from 1 to 499\n+            mapping_matrix[i + 1, x_S:x_L + 1, y_S:y_L + 1] = pixel_weight\n+\n+        # make sparse matrix of shape (num_pixels + 1, output_dim * output_dim)\n+        mapping_matrix = csr_matrix(mapping_matrix.reshape(num_pixels + 1, output_dim * output_dim))\n+\n+        return mapping_matrix\n+\n+    def rotate_cam(self, pos):\n+        rotation_matrix = np.matrix([[0.98198181, 0.18897548],\n+                             [-0.18897548, 0.98198181]], dtype=float)\n+        pos_rotated = np.squeeze(np.asarray(np.dot(rotation_matrix, pos)))\n+\n+        return pos_rotated\n+\n+    def rebinning(self):\n+        # placeholder\n+        raise NotImplementedError\n+\n+    # internal methods to create pixel pos numpy files \n+    def __get_pos_from_h5(self, tel_table, tel_type=\"MSTF\", write=False, outfile=None):\n+        selected_tel_rows = np.array([row.nrow for row in tel_table.where('tel_type=={}'.format(tel_type))])[0]\n+        pixel_pos = tel_table.cols.pixel_pos[selected_tel_rows]\n+        if write:\n+            if outfile is None:\n+                outfile = \"pixel_pos_files/{}_pos.npy\".format(tel_type)\n+            np.save(outfile, pixel_pos)\n+        return pixel_pos\n+    \n+    def __create_pix_pos_files(self, data_file):\n+        import tables # expect this to be run very rarely...\n+\n+        with tables.open_file(data_file, \"r\") as f:\n+            tel_table = f.root.Telescope_Info\n+            for row in tel_table.iterrows():\n+                self.__get_pos_from_h5(tel_table, tel=row[1].decode(\"utf-8\"), write=True)\n+\n+    def __read_pix_pos_files(self, tel_type):\n+        if tel_type in self.pixel_lengths: \n+            infile = \"pixel_pos_files/{}_pos.npy\".format(tel_type)\n+            return np.load(infile)\n+        else:\n+            logger.error(\"Telescope type {} isn't supported.\".format(tel_type))\n+            return False\n+ \n+\ndiff --git a/ctalearn/scripts/train.py b/ctalearn/scripts/run_model.py\nsimilarity index 60%\nrename from ctalearn/scripts/train.py\nrename to ctalearn/scripts/run_model.py\n--- a/ctalearn/scripts/train.py\n+++ b/ctalearn/scripts/run_model.py\n@@ -1,5 +1,6 @@\n import argparse\n-import configparser\n+from configobj import ConfigObj, flatten_errors\n+from validate import Validator\n import importlib\n import logging\n import os\n@@ -9,7 +10,9 @@\n import tensorflow as tf\n from tensorflow.python import debug as tf_debug\n \n-import ctalearn.data\n+from ctalearn.image_mapping import ImageMapper\n+from ctalearn.data_loading import DataLoader, HDF5DataLoader\n+from ctalearn.data_processing import DataProcessor\n \n # Disable Tensorflow info and warning messages (not error messages)\n os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'\n@@ -17,16 +20,19 @@\n \n def setup_logging(config, log_dir, debug, log_to_file):\n \n-    # Log configuration\n+    # Log configuration to a text file in the log dir\n     time_str = time.strftime('%Y%m%d_%H%M%S')\n     config_filename = os.path.join(log_dir, time_str + '_config.ini')\n-    with open(config_filename, 'w') as config_file:\n+    with open(config_filename, 'wb') as config_file:\n         config.write(config_file)\n \n     # Set up logger\n     logger = logging.getLogger()\n     \n-    if debug: logger.setLevel(logging.DEBUG)\n+    if debug: \n+        logger.setLevel(logging.DEBUG)\n+    else:\n+        logger.setLevel(logging.INFO)\n     \n     logger.handlers = [] # remove existing handlers from any previous runs\n     if not log_to_file:\n@@ -39,10 +45,10 @@ def setup_logging(config, log_dir, debug, log_to_file):\n     \n     return logger\n \n-def train(config, debug=False, log_to_file=False, predict=False):\n-    \n+def run_model(config, mode=\"train\", debug=False, log_to_file=False):\n+\n     # Load options relating to logging and checkpointing\n-    model_dir = config['Logging']['ModelDirectory']\n+    model_dir = config['Logging']['model_directory']\n     # Create model directory if it doesn't exist already\n     if not os.path.exists(model_dir): os.makedirs(model_dir)\n \n@@ -50,181 +56,112 @@ def train(config, debug=False, log_to_file=False, predict=False):\n     logger = setup_logging(config, model_dir, debug, log_to_file)\n     \n     # Load options to specify the model\n-    sys.path.append(config['Model']['ModelDirectory'])\n-    model_module = importlib.import_module(config['Model']['ModelModule'])\n-    model = getattr(model_module, config['Model']['ModelFunction'])\n-    model_type = config['Model']['ModelType']\n-    if model_type not in ['singletel', 'multipletel']:\n-        raise ValueError(\"model_type must be 'singletel' or 'multipletel', value provided: {}\".format(model_type))\n-\n-    model_hyperparameters = dict(config['Model'])\n+    sys.path.append(config['Model']['model_directory'])\n+    model_module = importlib.import_module(config['Model']['model_module'])\n+    model = getattr(model_module, config['Model']['model_function'])\n+    model_type = config['Data']['Data Loading']['example_type']\n     \n+    model_hyperparameters = config['Model']['Model Parameters']\n+    model_hyperparameters['model_directory'] = config['Model']['model_directory']\n+\n     # Load options related to the data format and location\n-    data_format = config['Data Format']['Format'].lower()\n+    data_format = config['Data']['format']\n     data_files = []\n-    with open(config['Data Format']['DataFilesList']) as f:\n+    with open(config['Data']['file_list']) as f:\n         for line in f:\n             line = line.strip()\n             if line and line[0] != \"#\":\n                 data_files.append(line)\n \n-    # Load options related to data input\n-    data_input_settings = {\n-            'batch_size': config['Data Input'].getint('BatchSize'),\n-            'prefetch': config['Data Input'].getboolean('Prefetch', True),\n-            'prefetch_buffer_size': config['Data Input'].getint(\n-                'PrefetchBufferSize', 10),\n-            'map': False, # default - will be set by data format\n-            'num_parallel_calls': config['Data Input'].getint(\n-                'NumParallelCalls', 1),\n-            'shuffle': config['Data Input'].getboolean('Shuffle', True),\n-            'shuffle_buffer_size': config['Data Input'].getint(\n-                'ShuffleBufferSize',10000)\n-            }\n-    \n+    # Load options related to image mapping\n+    image_mapping_settings = config['Image Mapping']\n+\n+    # Load options related to data loading\n+    if mode == \"train\":\n+        data_loader_mode = \"train\"\n+    elif mode == \"predict\":\n+        data_loader_mode = \"test\"\n+\n+    data_loading_settings = config['Data']['Data Loading']\n+\n     # Load options related to data processing\n-    data_processing_settings = {\n-            'validation_split': config['Data Processing'].getfloat(\n-                'ValidationSplit',0.1),\n-            'min_num_tels': config['Data Processing'].getint('MinNumTels', 1),\n-            'cut_condition': config['Data Processing']['CutCondition'],\n-            'sort_telescopes_by_trigger': config['Data Processing'].getboolean(\n-                'SortTelescopesByTrigger', False),\n-            'use_telescope_positions': config['Data Processing'].getboolean(\n-                'UseTelescopePositions', True),\n-            'crop_images': config['Data Processing'].getboolean('CropImages',\n-                False),\n-            'log_normalize_charge': config['Data Processing'].getboolean(\n-                'LogNormalizeCharge', False),\n-            'image_cleaning_method': config['Data Processing'].get(\n-                'ImageCleaningMethod', 'None').lower(),\n-            'return_cleaned_images': config['Data Processing'].getboolean(\n-                'ReturnCleanedImages', False),\n-            'picture_threshold': config['Data Processing'].getfloat(\n-                'PictureThreshold', 5.5),\n-            'boundary_threshold': config['Data Processing'].getfloat(\n-                'BoundaryThreshold', 1.0),\n-            'bounding_box_size': config['Data Processing'].getint(\n-                'BoundingBoxSize', 48),\n-            'num_shower_coordinates': 2, # position on camera needs 2 coords\n-            'model_type': model_type, # for applying cuts\n-            'chosen_telescope_types': ['MSTS'] # hardcode using SCT images only\n-            }\n+    apply_processing = config['Data']['apply_processing']\n+    data_processing_settings = config['Data']['Data Processing']\n+    data_processing_settings['num_shower_coordinates'] = 2 # position on camera needs 2 coords\n \n-    # Load options related to training hyperparameters\n-    training_hyperparameters = {\n-            'optimizer': config['Training Hyperparameters']['Optimizer'].lower(),\n-            'base_learning_rate': config['Training Hyperparameters'].getfloat(\n-                'BaseLearningRate'),\n-            'scale_learning_rate': config['Training Hyperparameters'].getboolean('ScaleLearningRate', False),\n-            'apply_class_weights': config['Training Hyperparameters'].getboolean('ApplyClassWeights', False),\n-            'variables_to_train': config['Training Hyperparameters'].getboolean(\n-                'VariablesToTrain', False),\n-            'adam_epsilon': config['Training Hyperparameters'].getfloat(\n-                'AdamEpsilon', 1e-8),\n-            'model_type': model_type\n-            }\n+    # Load options related to data input\n+    data_input_settings = config['Data']['Data Input']\n+    if data_format == 'HDF5':\n+        data_input_settings['map'] = True\n \n-    # Load options related to training settings\n-    num_epochs = config['Training Settings'].getint('NumEpochs', 0)\n-    if num_epochs < 0:\n-        raise ValueError(\"NumEpochs must be positive or 0: invalid value {}\".format(num_epochs))\n-    train_forever = False if num_epochs else True\n-    num_training_steps_per_validation = config['Training Settings'].getint(\n-        'NumTrainingStepsPerValidation', 1000)\n-\n-    # Load options related to prediction if needed\n-    if predict:\n-        true_labels_given = config['Predict'].getboolean('TrueLabelsGiven')\n-        export_prediction_file = config['Predict'].getboolean('ExportAsFile',\n-                False)\n+    # Load options related to training hyperparameters\n+    training_hyperparameters = config['Training']['Hyperparameters']\n+    training_hyperparameters['model_type'] = model_type\n+   \n+    # Load other options related to training \n+    num_epochs = config['Training']['num_epochs']\n+    train_forever = False if num_epochs != 0 else True\n+    num_training_steps_per_validation = config['Training']['num_training_steps_per_validation']\n+\n+    # Load options related to prediction only if needed\n+    if mode == 'predict':\n+        true_labels_given = config['Prediction']['true_labels_given']\n+        export_prediction_file = config['Prediction']['export_as_file']\n         if export_prediction_file:\n-            prediction_path = config['Predict']['PredictionFilePath']\n+            prediction_path = config['Prediction']['prediction_file_path']\n         # Don't allow parallelism in predict mode. This can lead to errors\n         # when reading from too many open files at once.\n         data_input_settings['num_parallel_calls'] = 1\n     \n     # Load options related to debugging\n-    run_tfdbg = config['Debug'].getboolean('RunTFDBG', False)\n+    run_tfdbg = config['Debug']['run_TFDBG']\n \n     # Define data loading functions\n-    if data_format == 'hdf5':\n-\n-        # Load metadata from HDF5 files\n-        metadata = ctalearn.data.load_metadata_HDF5(data_files)\n-\n-        # Calculate the post-processing image and telescope parameters that\n-        # depend on both the data processing and metadata, adding them to both\n-        # dictionaries\n-        ctalearn.data.add_processed_parameters(data_processing_settings,\n-                metadata)\n- \n-        if model_type == 'singletel':\n-            def load_data(filename, index):\n-                return ctalearn.data.load_data_single_tel_HDF5(\n-                        filename,\n-                        index,\n-                        metadata,\n-                        data_processing_settings)\n-\n-            # Output datatypes of load_data (required by tf.py_func)\n-            data_types = [tf.float32, tf.int64]\n-            output_names = ['telescope_data', 'gamma_hadron_label']\n-            outputs_are_label = [False, True]\n+    if data_format == 'HDF5':\n \n-        else:\n-            # For array-level methods, get a dict of auxiliary data (telescope\n-            # positions and any other data)\n-            auxiliary_data = ctalearn.data.load_auxiliary_data_HDF5(data_files)\n-\n-            def load_data(filename,index):\n-                return ctalearn.data.load_data_eventwise_HDF5(\n-                        filename,\n-                        index,\n-                        auxiliary_data,\n-                        metadata,\n-                        data_processing_settings)\n-\n-            # Output datatypes of load_data (required by tf.py_func)\n-            data_types = [tf.float32, tf.int8, tf.float32, tf.int64]\n-            output_names = ['telescope_data', 'telescope_triggers',\n-                    'telescope_aux_inputs', 'gamma_hadron_label']\n-            outputs_are_label = [False, False, False, True]\n+        data_loader = HDF5DataLoader(\n+                data_files,\n+                mode=data_loader_mode,\n+                image_mapper=ImageMapper(**image_mapping_settings),\n+                **data_loading_settings)\n \n         # Define format for Tensorflow dataset\n         # Build dataset from generator returning (HDF5_filename, index) pairs\n         # and a load_data function which maps (HDF5_filename, index) pairs\n         # to full training examples (images and labels)\n-        generator_output_types = (tf.string, tf.int64)\n-        map_func = lambda filename, index: tuple(tf.py_func(load_data,\n-            [filename, index], data_types))\n-\n-        data_input_settings['generator_output_types'] = generator_output_types\n+        data_input_settings['generator_output_types'] = tuple([tf.as_dtype(dtype) for dtype in data_loader.generator_output_dtypes])\n         data_input_settings['map'] = True\n-        data_input_settings['map_func'] = map_func\n-        data_input_settings['output_names'] = output_names\n-        data_input_settings['outputs_are_label'] = outputs_are_label\n-        \n+        map_fn_output_dtypes = [tf.as_dtype(dtype) for dtype in data_loader.map_fn_output_dtypes]\n+        data_input_settings['map_func'] = lambda *x: tuple(tf.py_func(data_loader.get_example,\n+            x, data_loader.map_fn_output_dtypes))\n+        data_input_settings['output_names'] = data_loader.output_names\n+        data_input_settings['output_is_label'] = data_loader.output_is_label\n+\n         # Get data generators returning (filename,index) pairs from data files \n         # by applying cuts and splitting into training and validation\n-        if not predict:\n-            training_generator, validation_generator = (\n-                    ctalearn.data.get_data_generators_HDF5(data_files,\n-                        metadata, data_processing_settings))\n-        else:\n-            test_generator = ctalearn.data.get_data_generators_HDF5(\n-                    data_files, metadata, data_processing_settings,\n-                    mode='test')\n+        if mode == 'train':\n+            training_generator, validation_generator, class_weights = data_loader.get_example_generators()\n+        elif mode == 'predict':\n+            test_generator, class_weights = data_loader.get_example_generators()\n+\n+        training_hyperparameters['class_weights'] = class_weights\n \n     else:\n         raise ValueError(\"Invalid data format: {}\".format(data_format))\n \n+    if apply_processing:\n+        data_processor = DataProcessor(\n+                image_charge_mins=data_loader.image_charge_mins,\n+                image_mapper=ImageMapper(**image_mapping_settings),\n+                **data_processing_settings)\n+        data_loader.add_data_processor(data_processor)\n+\n     # Define input function for TF Estimator\n     def input_fn(generator, settings): \n         # NOTE: Dataset.from_generator takes a callable (i.e. a generator\n         # function / function returning a generator) not a python generator\n         # object. To get the generator object from the function (i.e. to\n-        # measure its length), the function must be called (i.e. generator())\n+        # measure its length), the function must be called (i.e. generator())       \n         dataset = tf.data.Dataset.from_generator(generator,\n                 settings['generator_output_types'])\n         if settings['shuffle']:\n@@ -241,21 +178,20 @@ def input_fn(generator, settings):\n         # Return a batch of features and labels. For example, for an\n         # array-level network the features are images, triggers, and telescope\n         # positions, and the labels are the gamma-hadron labels\n-        iterator_outputs = iterator.get_next()\n-        features = {}\n-        labels = {}\n-        for output, output_name, is_label in zip(\n-                iterator_outputs,\n-                settings['output_names'],\n-                settings['outputs_are_label']):\n+        example = iterator.get_next()\n+\n+        features, labels = {}, {}        \n+        for tensor, name, is_label in zip(example, settings['output_names'], settings['output_is_label']):\n             if is_label:\n-                labels[output_name] = output\n+                labels[name] = tensor\n             else:\n-                features[output_name] = output\n+                features[name] = tensor\n \n         return features, labels\n \n     # Merge dictionaries for passing to the model function\n+    metadata = data_loader.get_metadata()\n+\n     params = {\n             'model': {**model_hyperparameters, **metadata},\n             'training': {**training_hyperparameters, **metadata}\n@@ -286,8 +222,7 @@ def model_fn(features, labels, mode, params, config):\n \n         training_params = params['training']\n \n-        # Compute class-weighted softmax-cross-entropy\n-        \n+        # Compute class-weighted softmax-cross-entropy        \n         true_classes = tf.cast(labels['gamma_hadron_label'], tf.int32,\n                 name=\"true_classes\")\n \n@@ -319,7 +254,7 @@ def model_fn(features, labels, mode, params, config):\n         # telescopes don't have smaller gradients\n         # Only apply learning rate scaling for array-level models\n         if (training_params['scale_learning_rate'] and\n-                model_type == 'multipletel'):\n+                model_type == 'array'):\n             trigger_rate = tf.reduce_mean(tf.cast(\n                 features['telescope_triggers'], tf.float32),\n                 name=\"trigger_rate\")\n@@ -334,29 +269,25 @@ def model_fn(features, labels, mode, params, config):\n \n         # Dict of optimizer_name: (optimizer_fn, optimizer_args)\n         optimizers = {\n-                'adadelta': (tf.train.AdadeltaOptimizer,\n+                'Adadelta': (tf.train.AdadeltaOptimizer,\n                     dict(learning_rate=learning_rate)),\n-                'adam': (tf.train.AdamOptimizer,\n+                'Adam': (tf.train.AdamOptimizer,\n                     dict(learning_rate=learning_rate,\n                         epsilon=training_params['adam_epsilon'])),\n-                'rmsprop': (tf.train.RMSPropOptimizer,\n+                'RMSProp': (tf.train.RMSPropOptimizer,\n                     dict(learning_rate=learning_rate)),\n-                'sgd': (tf.train.GradientDescentOptimizer,\n+                'SGD': (tf.train.GradientDescentOptimizer,\n                     dict(learning_rate=learning_rate))\n                 }\n \n-        if training_params['optimizer'] not in optimizers:\n-            raise ValueError(\"Optimizer {} not supported\".format(\n-                training_params['optimizer']))\n-\n         optimizer_fn, optimizer_args = optimizers[training_params['optimizer']]\n         optimizer = optimizer_fn(**optimizer_args)\n     \n         var_list = None\n-        if training_params['variables_to_train']:\n+        if training_params['variables_to_train'] is not None:\n             var_list = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,\n                     training_params['variables_to_train'])\n-       \n+        \n         # Define train op with update ops dependency for batch norm\n         update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\n         with tf.control_dependencies(update_ops):\n@@ -387,7 +318,7 @@ def model_fn(features, labels, mode, params, config):\n     # Log information on number of training and validation events, or test\n     # events, depending on the mode\n     logger.info(\"Batch size: {}\".format(data_input_settings['batch_size']))\n-    if not predict:\n+    if mode == 'train':\n         num_training_events = len(list(training_generator()))\n         num_validation_events = len(list(validation_generator()))\n         logger.info(\"Training and evaluating...\")\n@@ -399,11 +330,11 @@ def model_fn(features, labels, mode, params, config):\n             num_training_events/data_input_settings['batch_size'])))\n         logger.info(\"Number of training steps per validation: {}\".format(\n             num_training_steps_per_validation))\n-    else:\n+    elif mode == 'predict':\n         num_test_events = len(list(test_generator()))\n         logger.info(\"Predicting...\")\n         logger.info(\"Total number of test events: {}\".format(num_test_events))\n-    \n+\n     estimator = tf.estimator.Estimator(\n             model_fn, \n             model_dir=model_dir, \n@@ -416,7 +347,7 @@ def model_fn(features, labels, mode, params, config):\n             hooks = []\n         hooks.append(tf_debug.LocalCLIDebugHook())\n \n-    if not predict:\n+    if mode == 'train':\n         # Train and evaluate the model\n         num_epochs_remaining = num_epochs\n         while train_forever or num_epochs_remaining:\n@@ -428,7 +359,7 @@ def model_fn(features, labels, mode, params, config):\n                         data_input_settings), hooks=hooks, name='validation')\n             if not train_forever:\n                 num_epochs_remaining -= 1\n-    else:\n+    elif mode == 'predict':\n         # Generate predictions\n         predictions = estimator.predict(\n                 lambda: input_fn(test_generator, data_input_settings),\n@@ -476,10 +407,17 @@ def write_predictions(file_handle, predictions, true_labels):\n if __name__ == \"__main__\":\n \n     parser = argparse.ArgumentParser(\n-            description=(\"Train a ctalearn model.\"))\n+            description=(\"Train/Predict with a ctalearn model.\"))\n+    parser.add_argument(\n+            '--mode',\n+            default=\"train\",\n+            help=\"Mode to run in (train/predict)\")\n     parser.add_argument(\n             'config_file',\n-            help=\"path to configparser configuration file with training options\")\n+            help=\"path to configobj configuration file with training options\")\n+    parser.add_argument(\n+            'config_spec_file',\n+            help=\"path to configobj configspec file to validate configuration options\")\n     parser.add_argument(\n             '--debug',\n             action='store_true',\n@@ -488,15 +426,30 @@ def write_predictions(file_handle, predictions, true_labels):\n             '--log_to_file',\n             action='store_true',\n             help=\"log to a file in model directory instead of terminal\")\n-    parser.add_argument(\n-            '--predict',\n-            action='store_true',\n-            help=\"run in predict mode\")\n \n     args = parser.parse_args()\n    \n-    # Load configuration file\n-    config = configparser.ConfigParser(allow_no_value=True)\n-    config.read(os.path.abspath(args.config_file))\n-    \n-    train(config, args.debug, args.log_to_file, args.predict)\n+    # Load configuration file and configspec for validation\n+    validator = Validator()\n+    configspec = ConfigObj(args.config_spec_file, encoding='UTF8', list_values=False, _inspec=True, stringify=True)\n+    config = ConfigObj(args.config_file, configspec=configspec)\n+  \n+    # Validate config and print errors if any occurred\n+    # Error printing code based from example at\n+    # https://configobj.readthedocs.io/en/latest/configobj.html#validation\n+    result = config.validate(validator, preserve_errors=True)\n+    if result is True:\n+        run_model(config, mode=args.mode, debug=args.debug, log_to_file=args.log_to_file)\n+    else:\n+        for entry in flatten_errors(config, result):\n+            # each entry is a tuple\n+            section_list, key, error = entry\n+            if key is not None:\n+                section_list.append(key)\n+            else:\n+                section_list.append('[missing section]')\n+            section_string = ', '.join(section_list)\n+            if error == False:\n+                error = 'Missing value or section.'\n+            print(section_string, ' = ', error)\n+\ndiff --git a/misc/print_dataset_metadata.py b/misc/print_dataset_metadata.py\nnew file mode 100644\n--- /dev/null\n+++ b/misc/print_dataset_metadata.py\n@@ -0,0 +1,66 @@\n+import argparse\n+import sys\n+\n+import tables\n+import numpy as np\n+\n+from ctalearn.image import MAPPING_TABLES, IMAGE_SHAPES\n+from ctalearn.data import load_metadata_HDF5\n+\n+if __name__ == \"__main__\":\n+\n+    parser = argparse.ArgumentParser(\n+        description=(\"Print metadata for a given collection of standard\" \n+            \"CTA ML data files.\")\n+        )\n+    parser.add_argument(\n+        'file_list',\n+        help=\"List of CTA ML HDF5 (pytables) files comprising a dataset.\"\n+        )\n+    parser.add_argument(\n+        '--out_file',\n+        help=\"Optional output file to write results to.\"\n+        )\n+    \n+    args = parser.parse_args()\n+\n+    file_list = []\n+    with open(args.file_list) as f:\n+        for line in f:\n+            line = line.strip()\n+            if line and line[0] != \"#\":\n+                file_list.append(line)\n+\n+    metadata = load_metadata_HDF5(file_list)\n+\n+    out = open(args.out_file,\"w\") if args.out_file else sys.stdout\n+\n+    for i in metadata:\n+        print(\"{}: {}\\n\".format(i,metadata[i]), file=out)\n+\n+    num_events_by_id = metadata['num_events_by_particle_id']\n+    total_num_events = sum(num_events_by_id.values())\n+    print(\"{} total events.\".format(total_num_events), file=out)\n+    print(\"Num events by particle_id:\", file=out)\n+    for particle_id in num_events_by_id:\n+        print(\"{}: {} ({}%)\".format( \n+                particle_id, \n+                num_events_by_id[particle_id], \n+                100 * float(num_events_by_id[particle_id])/total_num_events),\n+                file=out\n+                )\n+\n+    for tel_type in metadata['telescopes'].keys():\n+        print(\"\\n\" + tel_type + \":\\n\", file=out)\n+        num_images_by_id = metadata['num_images_by_particle_id'][tel_type]\n+        total_num_images = sum(num_images_by_id.values())\n+        print(\"{} total images.\".format(total_num_images), file=out)\n+        print(\"Num images by particle_id:\", file=out)\n+        for particle_id in num_images_by_id:\n+            print(\"{}: {} ({}%)\".format( \n+                    particle_id, \n+                    num_images_by_id[particle_id], \n+                    100 * float(num_images_by_id[particle_id])/total_num_images),\n+                    file=out\n+                    )\n+\ndiff --git a/models/basic.py b/models/basic.py\n--- a/models/basic.py\n+++ b/models/basic.py\n@@ -1,30 +1,26 @@\n import tensorflow as tf\n \n-BASIC_FC_HEAD_LAYERS = [1024,512,256,128,64]\n-\n-BASIC_CONV_HEAD_LAYERS = [(64,3),(128,3),(256,3)]\n-\n def basic_conv_block(inputs, training, params=None, reuse=None):\n \n     with tf.variable_scope(\"Basic_conv_block\", reuse=reuse):\n \n         if params is None: params = {}\n         # Get standard hyperparameters\n-        bn_momentum = float(params.get('batchnormdecay', 0.99))\n+        bn_momentum = float(params.get('BatchNormDecay', 0.99))\n         # Get custom hyperparameters\n         filters_list = [int(f) for f in\n-                params.get('basicconvblockfilters').split('|')]\n+                params.get('BasicConvBlockFilters').split('|')]\n         kernels = [int(k) for k in\n-                params.get('basicconvblockkernels').split('|')]\n-        max_pool = bool(params.get('basicconvblockmaxpool', True))\n+                params.get('BasicConvBlockKernels').split('|')]\n+        max_pool = bool(params.get('BasicConvBlockMaxpool', True))\n         if max_pool:\n-            max_pool_size = int(params.get('basicconvblockmaxpoolsize'))\n-            max_pool_strides = int(params.get('basicconvblockmaxpoolstrides'))\n-        bottleneck = bool(params.get('basicconvblockbottleneck', False))\n+            max_pool_size = int(params.get('BasicConvBlockMaxPoolSize'))\n+            max_pool_strides = int(params.get('BasicConvBlockMaxPoolStrides'))\n+        bottleneck = bool(params.get('BasicConvBlockBottleneck', False))\n         if bottleneck:\n             bottleneck_filters = int(\n-                    params.get('basicconvblockbottleneckfilters'))\n-        batchnorm = bool(params.get('basicconvblockbatchnorm'))\n+                    params.get('BasicConvBlockBottleneckFilters'))\n+        batchnorm = bool(params.get('BasicConvBlockBatchNorm', False))\n         \n         x = inputs\n         if batchnorm:\n@@ -53,37 +49,62 @@ def basic_conv_block(inputs, training, params=None, reuse=None):\n \n     return x\n \n-def basic_head_fc(inputs, params=None, is_training=True):\n+def basic_fc_head(inputs, training, params=None):\n \n-    # Get hyperparameters\n+    # Get standard hyperparameters\n     if params is None: params = {}\n     num_classes = params.get('num_classes', 2)\n+    bn_momentum = float(params.get('BatchNormDecay', 0.99))\n+    \n+    # Get custom hyperparameters\n+    layers = [int(l) for l in params.get('BasicFCHeadLayers').split('|')]\n+    batchnorm = bool(params.get('BasicFCHeadBatchNorm', False))\n \n     x = tf.layers.flatten(inputs)\n \n-    for i, num_units in enumerate(BASIC_FC_HEAD_LAYERS):\n-        x = tf.layers.dense(x, units=num_units, activation=tf.nn.relu, name=\"fc_{}\".format(i+1))\n-        x = tf.layers.batch_normalization(x, training=is_training)\n+    for i, units in enumerate(layers):\n+        x = tf.layers.dense(x, units=units, activation=tf.nn.relu,\n+                name=\"fc_{}\".format(i+1))\n+        if batchnorm:\n+            x = tf.layers.batch_normalization(x, momentum=bn_momentum,\n+                    training=training)\n \n     logits = tf.layers.dense(x, units=num_classes, name=\"logits\")\n \n     return logits\n \n-def basic_head_conv(inputs, params=None, is_training=True):\n+def basic_conv_head(inputs, training, params=None):\n \n-    # Get hyperparameters\n+    # Get standard hyperparameters\n     if params is None: params = {}\n     num_classes = params.get('num_classes', 2)\n+    bn_momentum = float(params.get('BatchNormDecay', 0.99))\n+    \n+    # Get custom hyperparameters\n+    filters_list = [int(f) for f in\n+            params.get('BasicConvHeadFilters').split('|')]\n+    kernels = [int(k) for k in\n+            params.get('BasicConvHeadKernels').split('|')]\n+    avg_pool = bool(params.get('BasicConvHeadAvgPool', True))\n+    batchnorm = bool(params.get('BasicConvHeadBatchNorm', False))\n \n     x = inputs\n \n-    for i, (filters, kernel_size) in enumerate(BASIC_CONV_HEAD_LAYERS):\n-        x = tf.layers.conv2d(x,filters=filters,kernel_size=kernel_size,activation=tf.nn.relu,padding=\"same\",name=\"conv_{}\".format(i+1))\n-        x = tf.layers.batch_normalization(x, training=is_training)\n-\n-    pool = tf.layers.average_pooling2d(x, pool_size=x.get_shape().as_list()[1], strides=1, name=\"global_avg_pool\")\n-    flatten = tf.layers.flatten(pool)\n+    for i, (filters, kernel_size) in enumerate(zip(filters_list, kernels)):\n+        x = tf.layers.conv2d(x, filters=filters, kernel_size=kernel_size,\n+                activation=tf.nn.relu, padding=\"same\",\n+                name=\"conv_{}\".format(i+1))\n+        if batchnorm:\n+            x = tf.layers.batch_normalization(x, momentum=bn_momentum,\n+                    training=training)\n \n+    # Average over remaining width and length\n+    if avg_pool:\n+        x = tf.layers.average_pooling2d(x,\n+                pool_size=x.get_shape().as_list()[1],\n+                strides=1, name=\"global_avg_pool\")\n+    \n+    flatten = tf.layers.flatten(x)\n     logits = tf.layers.dense(flatten, units=num_classes, name=\"logits\")\n \n     return logits\ndiff --git a/models/cnn_rnn.py b/models/cnn_rnn.py\n--- a/models/cnn_rnn.py\n+++ b/models/cnn_rnn.py\n@@ -11,13 +11,13 @@ def cnn_rnn_model(features, params, training):\n     dropout_rate = float(params.get('dropoutrate', 0.5))\n \n     # Reshape inputs into proper dimensions\n-    num_telescope_types = len(params['processed_telescope_types']) \n+    num_telescope_types = len(params['selected_telescope_types']) \n     if not num_telescope_types == 1:\n         raise ValueError('Must use a single telescope type for CNN-RNN. Number used: {}'.format(num_telescope_types))\n-    telescope_type = params['processed_telescope_types'][0]\n+    telescope_type = params['selected_telescope_types'][0]\n     image_width, image_length, image_depth = params['processed_image_shapes'][telescope_type]\n-    num_telescopes = params['processed_num_telescopes'][telescope_type]\n-    num_aux_inputs = sum(params['processed_aux_input_nums'].values())\n+    num_telescopes = params['num_telescopes'][telescope_type]\n+    num_aux_inputs = params['total_aux_params']\n     num_gamma_hadron_classes = params['num_classes']\n     \n     telescope_data = features['telescope_data']\n@@ -29,8 +29,8 @@ def cnn_rnn_model(features, params, training):\n     telescope_triggers = tf.cast(telescope_triggers, tf.float32)\n \n     telescope_aux_inputs = features['telescope_aux_inputs']\n-    telescope_aux_inputs = tf.reshape(telescope_aux_inputs, [-1, num_telescopes,\n-        num_aux_inputs])\n+    telescope_aux_inputs = tf.reshape(telescope_aux_inputs,\n+            [-1, num_telescopes, num_aux_inputs])\n \n     # Transpose telescope_data from [batch_size,num_tel,length,width,channels]\n     # to [num_tel,batch_size,length,width,channels].\n@@ -48,9 +48,9 @@ def cnn_rnn_model(features, params, training):\n     # logits are returned and fed into a classifier.\n \n     # Load CNN block model\n-    sys.path.append(params['modeldirectory'])\n-    cnn_block_module = importlib.import_module(params['cnnblockmodule'])\n-    cnn_block = getattr(cnn_block_module, params['cnnblockfunction'])\n+    sys.path.append(params['model_directory'])\n+    cnn_block_module = importlib.import_module(params['CNNBlockModule'])\n+    cnn_block = getattr(cnn_block_module, params['CNNBlockFunction'])\n \n     #calculate number of valid images per event\n     num_tels_triggered = tf.to_int32(tf.reduce_sum(telescope_triggers,1))\n@@ -64,8 +64,8 @@ def cnn_rnn_model(features, params, training):\n             output = cnn_block(tf.gather(telescope_data, telescope_index),\n                 params=params, reuse=reuse, training=training)\n \n-        if params['pretrainedweights']:\n-            tf.contrib.framework.init_from_checkpoint(params['pretrainedweights'],{'CNN_block/':'CNN_block/'})\n+        if params['PretrainedWeights']:\n+            tf.contrib.framework.init_from_checkpoint(params['PretrainedWeights'],{'CNN_block/':'CNN_block/'})\n \n         #flatten output of embedding CNN to (batch_size, _)\n         image_embedding = tf.layers.flatten(output, name='image_embedding')\ndiff --git a/models/single_tel.py b/models/single_tel.py\n--- a/models/single_tel.py\n+++ b/models/single_tel.py\n@@ -6,7 +6,7 @@\n def single_tel_model(features, params, training):\n     \n     # Reshape inputs into proper dimensions\n-    num_telescope_types = len(params['processed_telescope_types']) \n+    num_telescope_types = len(params['selected_telescope_types']) \n     if num_telescope_types != 1:\n         raise ValueError('Must use a single telescope type for single telescope model. Number used: {}'.format(num_telescope_types))\n     telescope_type = params['processed_telescope_types'][0]\n@@ -17,15 +17,15 @@ def single_tel_model(features, params, training):\n     telescope_data = tf.reshape(telescope_data,[-1,image_width,image_length,image_depth], name=\"telescope_images\")\n \n     # Load neural network model\n-    sys.path.append(params['modeldirectory'])\n-    network_module = importlib.import_module(params['networkmodule'])\n-    network = getattr(network_module, params['networkfunction'])\n+    sys.path.append(params['model_directory'])\n+    network_module = importlib.import_module(params['NetworkModule'])\n+    network = getattr(network_module, params['NetworkFunction'])\n \n     with tf.variable_scope(\"Network\"):\n         output = network(telescope_data, params=params, training=training)\n \n-    if params['pretrainedweights']:\n-        tf.contrib.framework.init_from_checkpoint(params['pretrainedweights'],{'Network/':'Network/'})\n+    if params['PretrainedWeights']:\n+        tf.contrib.framework.init_from_checkpoint(params['PretrainedWeights'],{'Network/':'Network/'})\n \n     output_flattened = tf.layers.flatten(output)\n \ndiff --git a/models/variable_input_model.py b/models/variable_input_model.py\n--- a/models/variable_input_model.py\n+++ b/models/variable_input_model.py\n@@ -1,11 +1,7 @@\n-import tensorflow as tf\n+import importlib\n+import sys\n \n-from ctalearn.models.basic import basic_conv_block, basic_head_fc, basic_head_conv\n-from ctalearn.models.alexnet import (alexnet_block,\n-        alexnet_head_feature_vector, alexnet_head_feature_map)\n-from ctalearn.models.mobilenet import mobilenet_block, mobilenet_head\n-from ctalearn.models.resnet import (resnet_block, resnet_head)\n-from ctalearn.models.densenet import densenet_block\n+import tensorflow as tf\n \n # Drop out all outputs if the telescope was not triggered\n def apply_trigger_dropout(inputs,triggers):\n@@ -73,7 +69,7 @@ def combine_telescopes_as_feature_maps(telescope_outputs, telescope_aux_inputs,\n \n     return array_features\n \n-def variable_input_model(features, labels, params, is_training):\n+def variable_input_model(features, params, training):\n    \n     # Reshape inputs into proper dimensions\n     num_telescope_types = len(params['processed_telescope_types']) \n@@ -97,10 +93,6 @@ def variable_input_model(features, labels, params, is_training):\n     telescope_aux_inputs = tf.reshape(telescope_aux_inputs,\n             [-1, num_telescopes, num_aux_inputs], name=\"telescope_aux_inputs\")\n     \n-    # Reshape labels to vector as expected by tf.one_hot\n-    gamma_hadron_labels = labels['gamma_hadron_label']\n-    gamma_hadron_labels = tf.reshape(gamma_hadron_labels, [-1])\n-\n     # Split data by telescope by switching the batch and telescope dimensions\n     # leaving width, length, and channel depth unchanged\n     telescope_data = tf.transpose(telescope_data, perm=[1, 0, 2, 3, 4])\n@@ -116,41 +108,18 @@ def variable_input_model(features, labels, params, is_training):\n     # The array-level processing is then performed by the network head. The\n     # logits are returned and fed into a classifier.\n \n-    # Choose the CNN block\n-    if params['cnn_block'] == 'alexnet':\n-        cnn_block = alexnet_block\n-    elif params['cnn_block'] == 'mobilenet':\n-        cnn_block = mobilenet_block\n-    elif params['cnn_block'] == 'resnet':\n-        cnn_block = resnet_block\n-    elif params['cnn_block'] == 'densenet':\n-        cnn_block = densenet_block\n-    elif params['cnn_block'] == 'basic':\n-        cnn_block = basic_conv_block\n-    else:\n-        raise ValueError(\"Invalid CNN block specified: {}.\".format(params['cnn_block']))\n-\n-    # Choose the network head and telescope combination method\n-    if params['network_head'] == 'alexnet_fc':\n-        network_head = alexnet_head_feature_vector\n-        combine_telescopes = combine_telescopes_as_vectors\n-    elif params['network_head'] == 'alexnet_conv':\n-        network_head = alexnet_head_feature_map\n-        combine_telescopes = combine_telescopes_as_feature_maps\n-    elif params['network_head'] == 'mobilenet':\n-        network_head = mobilenet_head\n-        combine_telescopes = combine_telescopes_as_feature_maps\n-    elif params['network_head'] == 'resnet':\n-        network_head = resnet_head\n-        combine_telescopes = combine_telescopes_as_feature_maps\n-    elif params['network_head'] == 'basic_fc':\n-        network_head = basic_head_fc\n+    # Load CNN block and network head models\n+    sys.path.append(params['modeldirectory'])\n+    cnn_block_module = importlib.import_module(params['cnnblockmodule'])\n+    cnn_block = getattr(cnn_block_module, params['cnnblockfunction'])\n+    network_head_module = importlib.import_module(params['networkheadmodule'])\n+    network_head = getattr(network_head_module, params['networkheadfunction'])\n+    if params['telescopecombination'] == \"vector\":\n         combine_telescopes = combine_telescopes_as_vectors\n-    elif params['network_head'] == 'basic_conv':\n-        network_head = basic_head_conv\n+    elif params['telescopecombination'] == \"feature_maps\":\n         combine_telescopes = combine_telescopes_as_feature_maps\n     else:\n-        raise ValueError(\"Invalid network head specified: {}.\".format(params['network_head']))\n+        raise ValueError(\"Invalid telescope combination: {}.\".format(params['telescopecombination']))\n     \n     # Process the input for each telescope\n     telescope_outputs = []\n@@ -164,11 +133,11 @@ def variable_input_model(features, labels, params, is_training):\n             telescope_features = cnn_block(\n                 tf.gather(telescope_data, telescope_index), \n                 params=params,\n-                is_training=is_training,\n+                training=training,\n                 reuse=reuse)\n \n-        if params['pretrained_weights']:\n-            tf.contrib.framework.init_from_checkpoint(params['pretrained_weights'],{'CNN_block/':'CNN_block/'})\n+        if params['pretrainedweights']:\n+            tf.contrib.framework.init_from_checkpoint(params['pretrainedweights'],{'CNN_block/':'CNN_block/'})\n \n         telescope_features = apply_trigger_dropout(telescope_features,\n                 tf.gather(telescope_triggers, telescope_index, axis=1))\n@@ -179,11 +148,11 @@ def variable_input_model(features, labels, params, is_training):\n             telescope_outputs, \n             telescope_aux_inputs, \n             telescope_triggers,\n-            is_training)\n+            training)\n    \n     with tf.variable_scope(\"NetworkHead\"):\n         # Process the combined array features\n         logits = network_head(array_features, params=params,\n-                is_training=is_training)\n+                training=training)\n \n     return logits\n", "test_patch": "diff --git a/misc/test_metadata.py b/misc/test_metadata.py\ndeleted file mode 100644\n--- a/misc/test_metadata.py\n+++ /dev/null\n@@ -1,61 +0,0 @@\n-import tables\n-import numpy as np\n-\n-from ctalearn.image import MAPPING_TABLES, IMAGE_SHAPES\n-\n-from ctalearn.data import load_metadata_HDF5\n-\n-if __name__ == \"__main__\":\n-\n-    parser = argparse.ArgumentParser(\n-        description=(\"Print/write metadata for a given collection of standard CTA ML data files.\"))\n-    parser.add_argument(\n-        'file_list',\n-        help='List of HDF5 (pytables) files to compute metadata for.')\n-    parser.add_argument(\n-        '--telescope_type',\n-        help='Optional telescope type to examine when computing the image-wise class balance. If not provided,\n-        will compute the event-wise class balance.')\n-    parser.add_argument(\n-        '--output_file',\n-        help='Optional output file to write results to.')\n-    \n-    args = parser.parse_args()\n-\n-    file_list = []\n-    with open(\"/home/shevek/datasets/sample_prototype/file_list.txt\") as f:\n-        for line in f:\n-            line = line.strip()\n-            if line and line[0] != \"#\":\n-                file_list.append(line)\n-\n-    metadata = load_metadata_HDF5(file_list)\n-\n-    # Get number of examples by file\n-    num_examples_by_file = metadata['num_images_by_file'][args.telescope_type] if args.telescope_type else metadata['num_events_by_file']\n-\n-    # Log general information on dataset based on metadata dictionary\n-    logger.info(\"%d data files read.\", len(file_list))\n-    logger.info(\"Telescopes in data:\")\n-    for tel_type in metadata['telescope_ids']:\n-        logger.info(tel_type + \": \"+'[%s]' % ', '.join(map(str,metadata['telescope_ids'][tel_type]))) \n-    \n-    num_examples_by_label = {}\n-    for i,num_examples in enumerate(num_examples_by_file):\n-        particle_id = metadata['particle_id_by_file'][i]\n-        if particle_id not in num_examples_by_label: num_examples_by_label[particle_id] = 0\n-        num_examples_by_label[particle_id] += num_examples\n-\n-    total_num_examples = sum(num_examples_by_label.values())\n-\n-    logger.info(\"%d total examples.\", total_num_examples)\n-    logger.info(\"Num examples by label:\")\n-    for label in num_examples_by_label:\n-        logger.info(\"%s: %d (%f%%)\", label, num_examples_by_label[label], 100 * float(num_examples_by_label[label])/total_num_examples)\n-\n-\n-\n-    if args.output_file:\n-\n-    else:\n-        print(metadata)\ndiff --git a/tests/test_image_mapper.ipynb b/tests/test_image_mapper.ipynb\nnew file mode 100644\n--- /dev/null\n+++ b/tests/test_image_mapper.ipynb\n@@ -0,0 +1,395 @@\n+{\n+ \"cells\": [\n+  {\n+   \"cell_type\": \"code\",\n+   \"execution_count\": 1,\n+   \"metadata\": {\n+    \"collapsed\": true\n+   },\n+   \"outputs\": [],\n+   \"source\": [\n+    \"from ctalearn.image_mapping import *\\n\",\n+    \"\\n\",\n+    \"import matplotlib.pyplot as plt\\n\",\n+    \"%matplotlib inline\\n\"\n+   ]\n+  },\n+  {\n+   \"cell_type\": \"code\",\n+   \"execution_count\": 2,\n+   \"metadata\": {},\n+   \"outputs\": [\n+    {\n+     \"name\": \"stdout\",\n+     \"output_type\": \"stream\",\n+     \"text\": [\n+      \"CPU times: user 2.29 s, sys: 318 ms, total: 2.61 s\\n\",\n+      \"Wall time: 1.48 s\\n\"\n+     ]\n+    },\n+    {\n+     \"name\": \"stderr\",\n+     \"output_type\": \"stream\",\n+     \"text\": [\n+      \"/Users/qifeng/Data/deep-learning-CTA/ctalearn/image_mapping.py:336: VisibleDeprecationWarning: using a non-integer number instead of an integer will result in an error in the future\\n\",\n+      \"  mapping_matrix3d[i + 1, x, y] = 1\\n\",\n+      \"/Users/qifeng/Data/deep-learning-CTA/ctalearn/image_mapping.py:418: VisibleDeprecationWarning: using a non-integer number instead of an integer will result in an error in the future\\n\",\n+      \"  mapping_matrix3d[i + 1, x, y] = 1\\n\"\n+     ]\n+    }\n+   ],\n+   \"source\": [\n+    \"%%time\\n\",\n+    \"test_mapper = image_mapper(None)\\n\",\n+    \"\\n\"\n+   ]\n+  },\n+  {\n+   \"cell_type\": \"code\",\n+   \"execution_count\": 3,\n+   \"metadata\": {},\n+   \"outputs\": [\n+    {\n+     \"name\": \"stdout\",\n+     \"output_type\": \"stream\",\n+     \"text\": [\n+      \"CPU times: user 348 \u00b5s, sys: 105 \u00b5s, total: 453 \u00b5s\\n\",\n+      \"Wall time: 376 \u00b5s\\n\"\n+     ]\n+    }\n+   ],\n+   \"source\": [\n+    \"%%time\\n\",\n+    \"test_pix_valsV = np.arange(500) #first 0 is for padding, then 499 pix vals\\n\",\n+    \"test_imV = test_mapper.map_image(test_pix_valsV, 'VTS')\"\n+   ]\n+  },\n+  {\n+   \"cell_type\": \"code\",\n+   \"execution_count\": 4,\n+   \"metadata\": {},\n+   \"outputs\": [\n+    {\n+     \"name\": \"stderr\",\n+     \"output_type\": \"stream\",\n+     \"text\": [\n+      \"//anaconda/lib/python3.5/site-packages/matplotlib/cbook/deprecation.py:107: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\\n\",\n+      \"  warnings.warn(message, mplDeprecation, stacklevel=1)\\n\"\n+     ]\n+    },\n+    {\n+     \"data\": {\n+      \"image/png\": \"iVBORw0KGgoAAAANSUhEUgAAAP4AAAD8CAYAAABXXhlaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\\npEAKfJECKfBFCqTAFynQ/wHDWpLcFDvuYQAAAABJRU5ErkJggg==\\n\",\n+      \"text/plain\": [\n+       \"<Figure size 432x288 with 1 Axes>\"\n+      ]\n+     },\n+     \"metadata\": {},\n+     \"output_type\": \"display_data\"\n+    }\n+   ],\n+   \"source\": [\n+    \"plt.pcolor(test_imV[:,:,0])\\n\",\n+    \"plt.axes().set_aspect('equal')\"\n+   ]\n+  },\n+  {\n+   \"cell_type\": \"code\",\n+   \"execution_count\": 5,\n+   \"metadata\": {},\n+   \"outputs\": [\n+    {\n+     \"name\": \"stdout\",\n+     \"output_type\": \"stream\",\n+     \"text\": [\n+      \"CPU times: user 285 \u00b5s, sys: 220 \u00b5s, total: 505 \u00b5s\\n\",\n+      \"Wall time: 236 \u00b5s\\n\"\n+     ]\n+    }\n+   ],\n+   \"source\": [\n+    \"%%time\\n\",\n+    \"test_imS = test_mapper.map_image(np.arange(0,11329,1), 'MSTS')\"\n+   ]\n+  },\n+  {\n+   \"cell_type\": \"code\",\n+   \"execution_count\": 6,\n+   \"metadata\": {},\n+   \"outputs\": [\n+    {\n+     \"name\": \"stderr\",\n+     \"output_type\": \"stream\",\n+     \"text\": [\n+      \"//anaconda/lib/python3.5/site-packages/matplotlib/cbook/deprecation.py:107: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\\n\",\n+      \"  warnings.warn(message, mplDeprecation, stacklevel=1)\\n\"\n+     ]\n+    },\n+    {\n+     \"data\": {\n+      \"image/png\": \"iVBORw0KGgoAAAANSUhEUgAAAQsAAAD8CAYAAABgtYFHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\\nGwszS/L/U0nQgCRGd0YAAAAASUVORK5CYII=\\n\",\n+      \"text/plain\": [\n+       \"<Figure size 432x288 with 1 Axes>\"\n+      ]\n+     },\n+     \"metadata\": {},\n+     \"output_type\": \"display_data\"\n+    }\n+   ],\n+   \"source\": [\n+    \"plt.pcolor(test_imS[:,:,0])\\n\",\n+    \"plt.axes().set_aspect('equal')\\n\"\n+   ]\n+  },\n+  {\n+   \"cell_type\": \"code\",\n+   \"execution_count\": 7,\n+   \"metadata\": {},\n+   \"outputs\": [\n+    {\n+     \"name\": \"stdout\",\n+     \"output_type\": \"stream\",\n+     \"text\": [\n+      \"LST\\n\",\n+      \"CPU times: user 2 \u00b5s, sys: 1e+03 ns, total: 3 \u00b5s\\n\",\n+      \"Wall time: 6.2 \u00b5s\\n\",\n+      \"MSTN\\n\",\n+      \"CPU times: user 3 \u00b5s, sys: 0 ns, total: 3 \u00b5s\\n\",\n+      \"Wall time: 6.91 \u00b5s\\n\",\n+      \"SST1\\n\",\n+      \"CPU times: user 3 \u00b5s, sys: 1 \u00b5s, total: 4 \u00b5s\\n\",\n+      \"Wall time: 5.96 \u00b5s\\n\",\n+      \"MSTF\\n\",\n+      \"CPU times: user 3 \u00b5s, sys: 1 \u00b5s, total: 4 \u00b5s\\n\",\n+      \"Wall time: 6.2 \u00b5s\\n\",\n+      \"MSTS\\n\",\n+      \"CPU times: user 2 \u00b5s, sys: 1 \u00b5s, total: 3 \u00b5s\\n\",\n+      \"Wall time: 5.96 \u00b5s\\n\",\n+      \"SSTC\\n\",\n+      \"CPU times: user 2 \u00b5s, sys: 0 ns, total: 2 \u00b5s\\n\",\n+      \"Wall time: 7.15 \u00b5s\\n\",\n+      \"SSTA\\n\",\n+      \"CPU times: user 2 \u00b5s, sys: 1 \u00b5s, total: 3 \u00b5s\\n\",\n+      \"Wall time: 5.01 \u00b5s\\n\",\n+      \"VTS\\n\",\n+      \"CPU times: user 2 \u00b5s, sys: 0 ns, total: 2 \u00b5s\\n\",\n+      \"Wall time: 5.96 \u00b5s\\n\"\n+     ]\n+    }\n+   ],\n+   \"source\": [\n+    \"test_im_dict = {}\\n\",\n+    \"#for tel_ in ['LST', 'MSTN', 'SST1', 'MSTF', 'SSTC', 'SSTA']:\\n\",\n+    \"for tel_ in ['LST', 'MSTN', 'SST1', 'MSTF', 'MSTS', 'SSTC', 'SSTA', 'VTS']:\\n\",\n+    \"    print(tel_)\\n\",\n+    \"    %%time\\n\",\n+    \"    test_im_dict[tel_] = test_mapper.map_image(np.arange(0,test_mapper.PIXEL_NUM_DICT[tel_]+1,1), tel_)\"\n+   ]\n+  },\n+  {\n+   \"cell_type\": \"code\",\n+   \"execution_count\": 8,\n+   \"metadata\": {},\n+   \"outputs\": [\n+    {\n+     \"data\": {\n+      \"text/plain\": [\n+       \"'SSTC'\"\n+      ]\n+     },\n+     \"execution_count\": 8,\n+     \"metadata\": {},\n+     \"output_type\": \"execute_result\"\n+    }\n+   ],\n+   \"source\": [\n+    \"'SSTC'\"\n+   ]\n+  },\n+  {\n+   \"cell_type\": \"code\",\n+   \"execution_count\": 10,\n+   \"metadata\": {\n+    \"scrolled\": false\n+   },\n+   \"outputs\": [\n+    {\n+     \"name\": \"stdout\",\n+     \"output_type\": \"stream\",\n+     \"text\": [\n+      \"LST\\n\"\n+     ]\n+    },\n+    {\n+     \"data\": {\n+      \"image/png\": \"iVBORw0KGgoAAAANSUhEUgAAAQsAAAD8CAYAAABgtYFHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\\n\",\n+      \"text/plain\": [\n+       \"<Figure size 432x288 with 1 Axes>\"\n+      ]\n+     },\n+     \"metadata\": {},\n+     \"output_type\": \"display_data\"\n+    },\n+    {\n+     \"name\": \"stdout\",\n+     \"output_type\": \"stream\",\n+     \"text\": [\n+      \"MSTN\\n\"\n+     ]\n+    },\n+    {\n+     \"data\": {\n+      \"image/png\": \"iVBORw0KGgoAAAANSUhEUgAAAQsAAAD8CAYAAABgtYFHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\\n\",\n+      \"text/plain\": [\n+       \"<Figure size 432x288 with 1 Axes>\"\n+      ]\n+     },\n+     \"metadata\": {},\n+     \"output_type\": \"display_data\"\n+    },\n+    {\n+     \"name\": \"stdout\",\n+     \"output_type\": \"stream\",\n+     \"text\": [\n+      \"SST1\\n\"\n+     ]\n+    },\n+    {\n+     \"data\": {\n+      \"image/png\": \"iVBORw0KGgoAAAANSUhEUgAAAQsAAAD8CAYAAABgtYFHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\\nAABJRU5ErkJggg==\\n\",\n+      \"text/plain\": [\n+       \"<Figure size 432x288 with 1 Axes>\"\n+      ]\n+     },\n+     \"metadata\": {},\n+     \"output_type\": \"display_data\"\n+    },\n+    {\n+     \"name\": \"stdout\",\n+     \"output_type\": \"stream\",\n+     \"text\": [\n+      \"MSTF\\n\"\n+     ]\n+    },\n+    {\n+     \"data\": {\n+      \"image/png\": \"iVBORw0KGgoAAAANSUhEUgAAAQsAAAD8CAYAAABgtYFHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBo\\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJztnX+UXVWV57+7Xr2qQBUhBBRCghC6\\n0/wcaJ0M4I/lYknPEpDmxwz0wDgYFSe6xrbV6Z6G6B/OrzW2ravFnmkdoqB0LwbUCCSD2jYysly2\\nCxRaRcgPEhJIigQC+V35QepV7fnj3dQ757y6+5577/tVVd/PWm/Vu2/fc++pW6/23Wef791HVBWE\\nEJJFX7c7QAiZHtBZEEKioLMghERBZ0EIiYLOghASBZ0FISSKTGchIveIyE4Redb57Isisl5EnhGR\\nh0RknmNbISKbRGSDiLy3XR0nhHSWmMjiWwCuDD57FMCFqnoRgOcBrAAAETkfwM0ALkjafFVEKi3r\\nLSGka2Q6C1X9KYDdwWf/oKq1ZPMJAIuS99cBeEBV31DVLQA2Abikhf0lhHSJ/hYc48MAvp28X4i6\\n8zjGSPJZEyKyHMByAKig8s+Px9wWdIUQksYB7HldVd9UtH0pZyEinwVQA3DfsY+m2G1KPbmqrgSw\\nEgDmyny9VK4o0xVCSAY/1lUvlWlf2FmIyDIA1wC4QhsPmIwAOMPZbRGA7cW7RwjpFQpNnYrIlQBu\\nB3Ctqh5yTGsA3CwigyKyGMASAL8o301CSLfJjCxE5H4AlwM4RURGAHwO9dmPQQCPiggAPKGqH1PV\\n50TkOwDWoj48+biqjrer84SQziG98Ig6cxaEtJ8f66qnVXVp0fZUcBJCoqCzIIREQWdBCImCzoIQ\\nEgWdBSEkCjoLQkgUdBaEkCjoLAghUdBZEEKioLMghERBZ0EIiYLOghASBZ0FISQKOgtCSBR0FoSQ\\nKOgsCCFR0FkQQqKgsyCEREFnQQiJgs6CEBIFnQUhJAo6C0JIFHQWhJAo6CwIIVHQWRBCoqCzIIRE\\nQWdBCIki01mIyD0islNEnnU+my8ij4rIxuTnScnnIiJ/LSKbROQZEXlbOztPCOkcMZHFtwBcGXx2\\nB4DHVHUJgMeSbQC4CsCS5LUcwNda001CSLfJdBaq+lMAu4OPrwNwb/L+XgDXO5//rdZ5AsA8EVnQ\\nqs4SQrpH0ZzFqaq6AwCSn29OPl8IYJuz30jyGSFkmtPf4uPJFJ/plDuKLEd9qII5OL7F3SCEtJqi\\nkcWrx4YXyc+dyecjAM5w9lsEYPtUB1DVlaq6VFWXVjFYsBuEkE5R1FmsAbAseb8MwGrn8w8ksyKX\\nAdh3bLhCCJneZA5DROR+AJcDOEVERgB8DsBfAPiOiNwGYCuAm5LdfwDgagCbABwC8KE29JkQ0gUy\\nnYWq3pJiumKKfRXAx8t2ihDSe1DBSQiJgs6CEBIFnQUhJAo6C0JIFHQWhJAo6CwIIVHQWRBCoqCz\\nIIREQWdBCImCzoIQEgWdBSEkCjoLQkgUdBaEkCjoLAghUdBZEEKioLMghERBZ0EIiYLOghASBZ0F\\nISQKOgtCSBR0FoSQKOgsCCFRtHr5QuKw69+/w9s++es/b9iWB7aVP/e2D9xy2eT7E+5/Itr2xjWX\\neNuDj/wiygYAE+9+6+T7vp/+KtpWueg8b3v8mXWNfS8+3z/Ob9Z62/1nNhawq720zbeddWbD9uJL\\n/jlPPNE/5759UTZSHEYWhJAopL4uUHeZK/P1Umlas2jaEUYSTUy1bHTCwIGJQucs2g4AqvvHCrXr\\n3/eGty3Bd0gl/Rft23sg/cCSfu/SPXvtTrnnDPrDyKLOj3XV06q6tGh7RhaEkCiYs2gnRiSR3Tb9\\nTgnjzm0fs3h3rHNakUT2cQver6xzlukPSYWRBSEkilKRhYh8GsBHACiA36K+avoCAA8AmA/gnwDc\\nqqpHS/ZzetCmO7dtC7bDFFTRPpW5O7u3oDCl0o5IIoNtq/6Zt33Gjb8tfKzZTOHIQkQWAvgTAEtV\\n9UIAFQA3A/gCgC+r6hIAewDc1oqOEkK6S9mcRT+A40RkDMDxAHYAeA+Af5vY7wXwnwF8reR5epZQ\\nL+Fh3PUHRovPQg0cGI8/p0N1f80+sHH37t97JL2dccvp23fQPmefc86JYFZlb7FZjJfuXuR/0P0J\\nvxlBYWehqi+LyJcAbAVwGMA/AHgawF5VPfatHAGwcKr2IrIcwHIAmIPji3ajt8iKlAtG0tqufF3R\\n0L5MpqvPOGceW+BYzLakJZQZhpwE4DoAiwGcDmAIwFVT7DqlX1fVlaq6VFWXVjFYtBuEkA5RZhjy\\nBwC2qOprACAiDwJ4B4B5ItKfRBeLAGwv383eRZwRgfan2wBAK64tCLkr/p1RnDtnk63m2PrTbaFd\\nxv1so1b8e4Vrb7JNOLa+wFYLjtvv2CeCi9AXXKSaMzTqN2wDVd82nn5czQjFtjoJz7cw2RlNmYBy\\nK4DLROR4EREAVwBYC+AnAG5M9lkGYHW5LhJCeoEyOYsnRWQV6tOjNQC/ArASwPcBPCAi/z357O5W\\ndLRX2P2RIKHp3MjDSCJkcG+6NFvCMbjDnN3piUnJUHsP7EmftQ4jDZfq7kPp7Wr2Sft27U831tJ/\\nF935enq7MTs5+9LXndQYE5ptodRsiKp+DsDngo83A7hkit0JIdMYyr3LYgyPzaFzmeR90RmFcPaj\\nZTLyMnJvyranC5R7E0KiYGTRQjL1EEVvlGU0BO24c3cjkghmYDDh500Ojzam3+cMxT9d8PKDF3jb\\nC//Vc9FtZxt0FhE0JTUdLAcxaNSaCNtJMCIoWqeiaI0KAOjfZ6g0jX9kMWtU2I5Fdxt1KkIH4bD+\\nf/2eeVyLSl/xGiCzGQ5DCCFRMLLISRnptdU2j82NQtrVn7YNNSyMSKIMnEltDYwsCCFRMLKIwJJe\\n9zmy7YlQlh3KvZ2r3RdojCZCqbgr6a4Gd2pXKt4k906XXjfZqsG9wpVQVyo5bEEOoN+x18bTbQDU\\nOa4EkYWONfIvUg3k3gZHRge87cHh+ITnyPcunHy/6F8/G91uNsDIghASBSOLKdjz4ben2vrGDVm2\\nIecGmqMJl8E96Vrx8OEwr92uN1JtQPMDay7VXUatifBBLfeYuzLqTITRhMPEa7tSbW4kEbLhf/5O\\nsLPdBRdr9iProTPSgJEFISQKRhYl8Stbx9/uNMNNF77hlRFhtaWiePE7d5jDIN2FziInZcreZzmI\\nVKyivN1QU7bpGRPLOehokOAcCsZ0hp8+fNAvrnTckD10O8b2h3x15+k3zG51J103ISQKRhYAdt/m\\ny7nzLMc3uN9InhmueGBfRvELa6nDgpLuyv7DhdoBgOwdNYzpnZ3Yvcc+riXp/ssLUm3mMSvFZVj9\\nlcbfc4LJTw9GFoSQKBhZTEHRvEThnARQvPJ3cM6wclbxPEl77qqFk5ZlNNvUe7cERhaEkCgYWaBZ\\naBXKtk1Jt3MnD+/ilqQ7rLnZVMF7PF1i7lXhbqrzkL6ehlmFGzBl5NFS8NAeSsGbJN2NiyTVHF/H\\n0WDfcHbEoGjti9k+O8LIghASxayNLPZ+sPWSbkvODQCDe4wq3cY5zQrdhhQcAKqvW5Lu9LbyulGU\\nxpCCA1mS7vRrUHT2Ayg+A+LOfhAbRhaEkChmbWThklXiruh0e6lpemM2ovBsTavUnq2SggNco3Qa\\nMWudRa9VrSr+7EWw3eTo2vBMR9YxjZXRLedQGfUD3fHh+CGCKweX4XjR2sFRXwo+NBwnBQeAV1ef\\nN/n+1OvWRbebrnAYQgiJYtZEFns+lJ7QzGLgQHryzIomBg4YicCMu3N1nzGlZzSt7DMk3eGtIbhx\\nyz6jSrfBxB6rQrf9e276r7/f2MiTowwTmjnCOi8ZmuOc/RX/7znbamEwsiCERFHKWYjIPBFZJSLr\\nRWSdiLxdROaLyKMisjH5eVKrOtsxJHi17LjSeHWqP33Oy7KFdrevYX8tG5mxlI0svgLg71X1XAAX\\nA1gH4A4Aj6nqEgCPJduEkGlO4ZyFiMwF8G4AHwQAVT0K4KiIXAfg8mS3ewE8DuD2Mp1sBX1B+mDC\\nUSQ3PXwVqJktubdd3Ttd0m3Z6n1yJN0V36d7cu/QFizr58rBM+XeNUcwFVbTdoVY/f7XJhRaubJt\\ny5aFOzsyPlRsZgQAZKjY7MhxOaTgrzx8vrd92vVro9tOF8pEFmcDeA3AN0XkVyLyDREZAnCqqu4A\\ngOTnm6dqLCLLReQpEXlqDPHTVYSQ7lBmNqQfwNsAfEJVnxSRryDHkENVVwJYCQBzZX7LHyLe9wF7\\n9iOMJlzm7Ek3hg+AuQzutfXetqQ7fZ1RCR/Gcujfbci50RxNeLbXjMI0tfTfZfzV18xzWnJwb/Yj\\nDyUK2hSXgmcUKJpllIksRgCMqOqTyfYq1J3HqyKyAACSnzvLdbE1qPivom3z2EzKJC0LJ0ozEpMF\\njyt94r1ibW1Dg1eepiqTL+JT2Fmo6isAtonIOclHVwBYC2ANgGXJZ8sArC7VQ0JIT1BWlPUJAPeJ\\nyACAzQA+hLoD+o6I3AZgK4CbSp6jEG1bMNgiQ3pdeBq2GxW8rUOWiBCqo37bseG4W39l1M86jw/H\\nDxEmgoRnX6QcfHT0OG97eDi+hulr//dcb/tNf7g+um2vUspZqOqvASydwnRFmeMSQnqPGSX33rvM\\nSGoad/2BA8VrGtiS7nRTdX/GtJxx16/sPVSoHfZkLDvoVrEKpmBNSbfBi5/x7yXhE70W7hR2Uzsj\\n/NN+f+fmtunn7Ot3S5/557DyGNV+/3swEyuDU+5NCIliRkUWHlmO3bJbK261S97cheUBw3qY0TYJ\\nbBo+kcZ70EyEf1VCSBQzKrLwKm0Hkm0JUguuvUkKHlwV87hODUwNKmKH9TFde5b02rU3V+F22vYH\\nHaoFv4xrn7ArbXtCrEDSPeHItvsGBjybBiIsCftr4M6OjA3FJzTKFMpxZ0eaZkaMXMPo6Bxve3i4\\nIaTLylHsXNOYHXnztdNzZmRaO4t9t6YnNEPnEGKqNA2l5eDu9Gk3S90JAAO7DZWmobSs7DKWDgyd\\nQ8iugirNnekqTa3ZU48vrnib3ae041ay90lvW0yl2aTuzJGYnG1LHXIYQgiJYlpHFrkoWHMzE8vd\\nGrawNmaexZhN2iTgaptU2wgI8kyztqIdsWFkQQiJYuZGFhk3QjOasGTbJdyrFS30WiRht7OnTqtO\\nKc+xE+IPG0rBa7kSno2Ex8RQvBS8FkjB+3Msg7jfSXgOD8WXWdj9/d/ztue/7/nott2EkQUhJIpp\\nF1lYMyBWNDGw35hay7jBDhyIv9u49FsVujOo7Cso6d5rSLozIonxXbuNtun3le2fvtT/wNWwZQQH\\nRWdAujFz0ldiqcOZsEwiIwtCSBTTLrLwKLUCWLFm1ixGqeUBLbfdC3mJWUjTKo0l2s4E+I0ghEQx\\n7SKLWEl3ky1QV+aqtO1KuqvpFbyb5N6BDForjU5ZVbgB+HUsK5VoW7P02qm0HSg2JazS7bQNJduu\\nalP6g8rfxl20Gixylmd2pN+ZHalFFskBgL6gUM5EjkI57uxIJUdV8AOhFHwoXa0bsuuRcybfn3zN\\nhuh2nabnncX+9xeTdA/utb8gpqR7T/qXpM+QZQ/sMpKSaHYQLpXXjaUDjQK4aiUl0ewgXGoFJd3b\\nP/Uvgp3NLvi7FoxlmxKauepihJLuuHZZCU2rvoWV0Jyu9T05DCGERNHzkUUu2lXjstu1M5sybQVr\\nZ5ZJWjLhOevhN4AQEkXvRxaW9LrU1GmxxuYDYF2owh1GCxpIrwtHE0a7avDE/NhQ/GH7g7a14ch2\\nBwIpeJjwNPIQTZXBXTm4kT+oHfTrdvTnWM7wwEE/4XlCZMJz7/eXeNvz3rcx+pzthpEFISSKnoss\\n9v87e9lBW9JtVdpObziwz54is8RW/fuNB4iMWp59lpw7i737jVOm+//abqMQDmBGE69/9LLMbk3F\\nRBlZdtFbWReWOqyUkYL3OVXReljMxciCEBJFz0UWLaNE/qBtj4t34zF087jtuVe4D4/lulG2agW3\\nFlHmLj9dtRQWPecsVn3+i972jSv+k7f90Oe/NPn+hhV/5tn+x513Tb7/zKc/5tm+cOdXve3bP/Uf\\nJt9/8C5/OdZvfux6b/sjdz00+f4bH73Bs7373qcm3//0g75Y6d3f+qW37drPfGCHZ3vp5gXetmt/\\n6ZbTPdvAQ40/29Ebaqm20H7gB2d7thOu3uxtj/5w8eT74au2IJaBEglPr/ZFZLKz3q7YMogAUBlt\\nXKPxHLUvxkbDhGe8wnO/sxRibLIT6K2EJ4chhJAoREtmVESkAuApAC+r6jUishjAAwDmA/gnALeq\\nqjnndNHFVf3+D06Z0lYxYtEXxo6P7mdF/ATUxqOnTb7vg52cqjhx9aYjp5rHtXjp8MmNc+Zo9/Kh\\ned52X44ik68ejH8YQ5zjHlnt/555amW+cWJ6O6vrR+fGnyNk7ETjehpDgom56XL4rH+NwbnpyW1r\\nGHLSCenJ7axzloksfqyrnlbVqdYmjqIVkcUnAaxztr8A4MuqugTAHgC3teAchJAuU8pZiMgiAO8D\\n8I1kWwC8B8CqZJd7AVw/devpw7jK5KvZ1jf5ysOE9nmvfG1l8kVIpygbWdwJ4M+ByTj+ZAB7VfVY\\nbDcCYOFUDUVkuYg8JSJP7d41/UuOETLTKTwbIiLXANipqk+LyOXHPp5i1ylHYaq6EsBKAJgr8/XD\\nZ7wLAHDPtp95+40Hzd0cxu9U/bFfnhzGkoFXGu2Ovjm63e/OedXbdnMYYXQR5jPOPG7X5Hs3fwGg\\nKbpwcxoLj9/r2dwcRhhdhPmMU4ca0w158hdzrvN/zyMPN37PrPyBKwfPNTNy0N/OJSM/0Lh+tRPi\\nbz4SSME1R+2Lo87syMBwvBR878HjvO15Q4ej23aTMlOn7wRwrYhcDWAOgLmoRxrzRKQ/iS4WAdhe\\nvpuEkG5T2Fmo6goAKwAgiSz+TFXfLyLfBXAj6jMiywCsTj3IFIQ1aYKiVV6kEc6UTDijqnCGw7rr\\nTwSjsazZkU7gRhp5Zk6sSCMrCnEz+JJjxqWUpLtV1b1zFeBp1bqo8W3dQjp5BFsz/UGy2wH8RxHZ\\nhHoO4+42nANA3XG4L5cJ9HmvprZGYtJq6yY7p0p49hpWMtS1hXZV8V55EG28cqHBi/QULVFwqurj\\nAB5P3m8GcEkrjksI6R1Ki7JawVyZr5fKFVPawoRn1Rl6jAW3nznOsw5rjw4FNl+ae9SJY+f0+cKc\\ntW/48mq37dEg/h1wCoFuOOJLtuf0+eccc9pWgwKimw75Sdb+voY9vOtXnWHJiwfnB+38IUttonFN\\nBir+Obft98VeVcc+PuFHVP2O7dD3/N8zHIZYEUWYtPQup9GuZrXLahtIwWOHIeEyiHmGIdVACh47\\nDDnxeD/Z2cphSC+Isgghs4Cee5AsxJJ7Vy2b2EsODhilwcO7fnS7Pvuc1nHdSKK5XXqCM4wk8tgr\\nBW09kdDM07ZVCc0cFF3qsJcSmiGMLAghUfR8ZNEqxoMopIL0KcXmtg2fWskxrWqdsxdxr4M1rUqm\\noMz16e2vxSSMLAghUfT8bEjI3237x1RbxagotXFs0N83hzt/YSxdDm5FGpuPvsloZ5//xSMnp9qs\\ntiOH56Xash5t3z7aeEbc2jcUbI0+7M+OWKcJZS1ewZsc7ZqqgudqGxkdhiVUTwhyUu45w8giyHcM\\nDjceZ2+K0pxdz/yjZ+L6VgDOhhBCOsK0y1m494TQ0407UZIVZfQCWfkMK3/gtrXahW2z5N7tII8G\\nIyRWg2G2y9vW+VI19dU6TtPsR7MiNo12RhOtZNo5C5fwz+M6j/GM4ZX1D9cNQufRqnaW07ESu5Zj\\nYbJzdsJhCCEkimmX4HS5N0h2Djpy77FgGb854sema8eqjs1PXI0Fcawrplp/NJB0S6OOwZj6gVoo\\nDNvwxgLH5ouwwnO6fdp42E+wum3DdoOBMGzzaKO26UAg/KoFmT/XvvVAvBQ8FHAdeLAhl++EFBzw\\n5eBZwxC3D2NB7Ys8wxAv4Zl123XahrUvzrypM8MQJjgJIR1hWucsqkYSs5qxgI4lobZk2ZaMPEti\\nbh03jG5crJyKdUzAlnv3G9egqBQcKC4HLyXpLnrOMrdLT0Yen8fpVCTRahhZEEKimNaRRciEcwfu\\nCzx9WBzHtwVj8FyS7mJS8HZhznAE16QvY9o1zdbSKdeChzK7UKJ7HZhNnrYwsiCERDGtZ0NC/s/I\\nzyffh5GFxeaaHWBZEcMLY5ak25KC2xXFrTyFJQUPcaOArYf8QjlhZGGx41B6ZXAr0ti32i8kZM0w\\nhHkHSwoeHsdtm1UV3G0b5lfGh6yVzcJzOh9kVQV3dl3yoafS92sjZWdDZtQwpF0Uf+o0fXhjlf6v\\nt7VUmsWK+XaDrLDem23OoZicCL65eYYPE9Y5DbREfYtuOYhWwmEIISSKGRtZTAS3jDzDknYRRhrx\\n7azEox2hlEl4khLMwEvJyIIQEsWMSnC6uMlOABiEn8kac/IH1cBnbqj5265gaiy4k7virvVHT/Vs\\nYb1Or6J4UG3clYLXj5su6XbbbjjktxusBNJ1R5odSsFfOOgnZwccey3I/Lk1QreNBlLwQEbursUS\\nLuG456FF3rYp6XZl2WH9Cus2FxwnbGsJsdzcR1j3wqzlGUZww/617oWcBeXehJCOMGNzFmG0kMc+\\ngGKVtq3K31n2opJuqyo4AFQLyr2t41rtgOZowqVV1b0L18UAovMJTbMfOc7ZC5FEq2FkQQiJYsZG\\nFiFlZkfaJnUuiDWrEq6/WnErZWXcG4rqN8JiOHkWVZ6JswYzlcIJThE5A8DfAjgN9aJVK1X1KyIy\\nH8C3AZwF4EUAf6Sqe6xjtSPBGfLdkSdSbVmOY0st/RpZzmPz2CmptqyV2rMUnscIRWIvHDGKC2f8\\nE287dFKqzXIeOw7OTbVlOY7dqxelGw11Z7icYVq7qdpaCk/xzukfqBaqO41p6SWfSP++dYtuJjhr\\nAP5UVc8DcBmAj4vI+QDuAPCYqi4B8FiyTQiZ5hQehqjqDgA7kvcHRGQdgIUArgNwebLbvaivrn57\\nqV62mawhSmyB3KbCujmGBGGk0WuS7m4MUbqy1GFBSXcvRhKtpiUJThE5C8BbATwJ4NTEkRxzKHHx\\nNCGkpymd4BSRYQDfA/ApVd0vkSX4RWQ5gOUAMAfHl+1GT5C5DKJjD/MHVvLRknQXlZB3C7MyeJlk\\nZ4vqYjDfmk6pb5qIVFF3FPep6oPJx6+KyILEvgDAzqnaqupKVV2qqkurGJxqF0JID1E4spB6CHE3\\ngHWq+leOaQ2AZQD+Ivm5ulQPW8RNiy7ztt3ZkbBeZ7jmyHnVxiD4+TFfxuuKtEIp+AUDr3rbzzly\\n8LBeZ1gZ/Pw5I5Pv1x7xZwwsKfiS4/xzbjzcOGe/hNW9/baLh16ffL/loD+T44q0wgjqjOG93rYr\\nBw/rdYaVwd98w9bJ9zsffAtiqY7621k1LNLamrMqAf2j/vVqmh2Z4ZQZhrwTwK0Afisiv04++wzq\\nTuI7InIbgK0AbirXRUJIL1BmNuRnSC9p3F7RRAuwqn9XJT2dblcFt+807aganlXd25SKF5SRZ8q9\\nC1YG1/DbWEbSHXkcc/YjIwc1G2ZAXGaNgrPXGA+GLOHzFFbisqiitBtrnZKZw/RKpRNCusaMrWeR\\nh4df/oVp7zN86pba0VSb9STp84EU3HpSM2TzG+nSFStaePFIuvw8q+22w4YU3Pg9tx9Kl4JnnfPV\\n1Y2EZ1YQ5OZNa2HtC2ukEfxpa8Ou3tsehiy+4+emvddgPQtCSEdgzgLNU6WVQFg24UixwyjDkoKH\\ntTOtSKMXsHIhps2o5ZmVJymcfylxm8uz4LLLdIskWg0jC0JIFIwscjJhPFqeFUlYVbqzZkemE2Gk\\n4dmMSCNLLm/R/drtMx9GFoSQKDgbMgXh7Ei/Uxm8FtTnHJTq5Pt1Y0c825wgOhhz7pyh7bmjfqVt\\nt4L3WFCZvOr0IawKPqfPrxp+1FE6DQTirucPn+Yf1xFphToP17b5UCAFD36XmhMlDQQVxV884C+h\\nOFBpHLcWJCJc2/YHz/JsYc7CiixCKXhsziKUgk/3nAVnQwghHYE5iymwdBX9SNcVD2SUyqsa2f7w\\nru+1M6uNZ1UULyYVt2Xi9u9pVw0vZmvZ7EcOpnsk0WroLEoyrsYXPPANfU6sbCU7AT9JmGdZwemW\\nKI2driXdh8MQQkgUTHBG8MjLT0ftVwmeZH1h7JC33ZfjRrl5bF6qzYo0rKrgWVHGliNvSrVZgqmt\\nh+en2rLqdY4cbPyeeURZ21ef6W1blzYMUMZOcI3p7c74bzNrGMIEJyGkIzBnEYFb/TvP4kS9Rp7H\\n4sP1SPLkFnyhVXr90HbRtPBxjuB5pkUTrYSRBSEkCkYWObHWGLFmRgB/diRP/qJdhJFGLFmzFHYU\\nElfUZ6q2pLswsiCERMHIIoJrFzYSyGtefsqzVaVxCcfUF0AtqfpVWDaONcpKV4MIZSzIhZxTbSwP\\nu2HMLzwz4AimjgaKo3MHd3jb6x05eCi0CiuDn3fc9sn3TVJwpybn2ERQUXzIX+1h48HGjEw1qOUZ\\ntl08vHvy/ZZRf1bFFXfVgojkLddv8ba3PbwYsVQPOP0JC+WQVOgscmIX87Uvp6XgDJ2H3y5dTTlQ\\nomCvZbOGAKEDCLGK/VptTXVnRmK04IiKCc0ccBhCCImCkUVJrCpadjufPF7bqs7VDaz6Fdbi0Flt\\ni0reM+n+JZuWMLIghERBuXdJfrj9V6k2K9J4sXYg1VZvm87mWnrFbCvSeMGQggO2HHzLG+lS8BA3\\nCthy+OTgHPHft5cPnRh1jpCta4JkZ7irs33anbMnZ0G5NyGkIzBn0aO49/ii+QzAjzSsKtyAL9Jq\\nkoIbtm5g/i4ZwctsiiZaCSMLQkgUbXMWInKliGwQkU0icke7zkNsxiGTr5AJiPfy2mmf94q1hcdt\\n6o+K9yLTh7YMQ0SkAuBvAPxLACMAfikia1R1bTvO102uOv2tk+/DZOd7T7/Y2/7R9t9Mvv/oW97l\\n2e7a+jNv27V/PbB9/uyLJt9x5eErAAAFFElEQVSv2PxMqi20f/tcX5X5b9a/4m3ff25D7XnLel8J\\n+sTFja/KZb/xlar/eNGAt/3OZxpLOo5cOurZFj3pSyZfuuTg5Pszf+FXyK1d3lCU9j9+eqoNAAYe\\nb/T9tC/7w4xXPv0OkPK0K7K4BMAmVd2sqkcBPADgujadixDSAdoydSoiNwK4UlU/kmzfCuBSVf1j\\nZ5/lAJYnmxcCeLblHSnOKQBe73YnAnqtT+yPTa/1BwDOUdUTsnebmnbNhkw1GPW8kqquBLASAETk\\nqTLzv62m1/oD9F6f2B+bXusPUO9TmfbtGoaMADjD2V4EYHvKvoSQaUC7nMUvASwRkcUiMgDgZgBr\\n2nQuQkgHaMswRFVrIvLHAH4EoALgHlV9zmiysh39KEGv9QfovT6xPza91h+gZJ964tkQQkjvQwUn\\nISQKOgtCSBRddxbdloWLyBki8hMRWSciz4nIJ5PP54vIoyKyMfl5UtaxWtyvioj8SkQeSbYXi8iT\\nSX++nSSOO9WXeSKySkTWJ9fp7T1wfT6d/L2eFZH7RWROJ6+RiNwjIjtF5FnnsymvidT56+Q7/oyI\\nvK1D/fli8jd7RkQeEpF5jm1F0p8NIvLemHN01Vk4svCrAJwP4BYROb/D3agB+FNVPQ/AZQA+nvTh\\nDgCPqeoSAI8l253kkwDWOdtfAPDlpD97ANzWwb58BcDfq+q5AC5O+tW16yMiCwH8CYClqnoh6kn0\\nm9HZa/QtAFcGn6Vdk6sALEleywF8rUP9eRTAhap6EYDnAawAgOT7fTOAC5I2X03+F21UtWsvAG8H\\n8CNnewWAFV3u02rUn2nZAGBB8tkCABs62IdFqH/Z3gPgEdRFbq8D6J/qurW5L3MBbEGSDHc+7+b1\\nWQhgG4D5qM/oPQLgvZ2+RgDOAvBs1jUBcBeAW6bar539CWw3ALgvee/9n6E+a/n2rON3exhy7I9+\\njJHks64gImcBeCuAJwGcqqo7ACD5aZeZai13AvhzNMpanAxgr+rkWgOdvE5nA3gNwDeTYdE3RGQI\\nXbw+qvoygC8B2ApgB4B9AJ5G967RMdKuSS98zz8M4Idl+tNtZ5EpC+8UIjIM4HsAPqWq+7vRh6Qf\\n1wDYqaru0u3dvE79AN4G4Guq+lYAB9H5IZlHkgu4DsBiAKcDGEI91A/pFV1AV7/nIvJZ1Ifb95Xp\\nT7edRU/IwkWkirqjuE9VH0w+flVEFiT2BQB2prVvMe8EcK2IvIj607rvQT3SmCcyuTBJJ6/TCIAR\\nVX0y2V6FuvPo1vUBgD8AsEVVX1PVMQAPAngHuneNjpF2Tbr2PReRZQCuAfB+TcYcRfvTbWfRdVm4\\niAiAuwGsU9W/ckxrACxL3i9DPZfRdlR1haouUtWzUL8e/09V3w/gJwBu7EJ/XgGwTUTOST66AsBa\\ndOn6JGwFcJmIHJ/8/Y71qSvXyCHtmqwB8IFkVuQyAPuODVfaiYhcCeB2ANeq6qGgnzeLyKCILEY9\\n8fqLzAN2KillJGWuRj1T+wKAz3bh/O9CPQR7BsCvk9fVqOcJHgOwMfk5vwt9uxzAI8n7s5M/6CYA\\n3wUw2MF+/D6Ap5Jr9DCAk7p9fQD8FwDrUS9t8HcABjt5jQDcj3q+ZAz1O/VtadcE9bD/b5Lv+G9R\\nn8XpRH82oZ6bOPa9/t/O/p9N+rMBwFUx56DcmxASRbeHIYSQaQKdBSEkCjoLQkgUdBaEkCjoLAgh\\nUdBZEEKioLMghETx/wEaKLmKht8iewAAAABJRU5ErkJggg==\\n\",\n+      \"text/plain\": [\n+       \"<Figure size 432x288 with 1 Axes>\"\n+      ]\n+     },\n+     \"metadata\": {},\n+     \"output_type\": \"display_data\"\n+    },\n+    {\n+     \"name\": \"stdout\",\n+     \"output_type\": \"stream\",\n+     \"text\": [\n+      \"MSTS\\n\"\n+     ]\n+    },\n+    {\n+     \"data\": {\n+      \"image/png\": \"iVBORw0KGgoAAAANSUhEUgAAAQsAAAD8CAYAAABgtYFHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\\nGwszS/L/U0nQgCRGd0YAAAAASUVORK5CYII=\\n\",\n+      \"text/plain\": [\n+       \"<Figure size 432x288 with 1 Axes>\"\n+      ]\n+     },\n+     \"metadata\": {},\n+     \"output_type\": \"display_data\"\n+    },\n+    {\n+     \"name\": \"stdout\",\n+     \"output_type\": \"stream\",\n+     \"text\": [\n+      \"SSTC\\n\"\n+     ]\n+    },\n+    {\n+     \"data\": {\n+      \"image/png\": \"iVBORw0KGgoAAAANSUhEUgAAAP4AAAD8CAYAAABXXhlaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\\nK8W5WuEAAAAASUVORK5CYII=\\n\",\n+      \"text/plain\": [\n+       \"<Figure size 432x288 with 1 Axes>\"\n+      ]\n+     },\n+     \"metadata\": {},\n+     \"output_type\": \"display_data\"\n+    },\n+    {\n+     \"name\": \"stdout\",\n+     \"output_type\": \"stream\",\n+     \"text\": [\n+      \"SSTA\\n\"\n+     ]\n+    },\n+    {\n+     \"data\": {\n+      \"image/png\": \"iVBORw0KGgoAAAANSUhEUgAAAP4AAAD8CAYAAABXXhlaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\\nWYGc+GYFcuKbFciJb1YgJ75Zgf4PnY4duAT6SHQAAAAASUVORK5CYII=\\n\",\n+      \"text/plain\": [\n+       \"<Figure size 432x288 with 1 Axes>\"\n+      ]\n+     },\n+     \"metadata\": {},\n+     \"output_type\": \"display_data\"\n+    },\n+    {\n+     \"name\": \"stdout\",\n+     \"output_type\": \"stream\",\n+     \"text\": [\n+      \"VTS\\n\"\n+     ]\n+    },\n+    {\n+     \"data\": {\n+      \"image/png\": \"iVBORw0KGgoAAAANSUhEUgAAAP4AAAD8CAYAAABXXhlaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\\npEAKfJECKfBFCqTAFynQ/wHDWpLcFDvuYQAAAABJRU5ErkJggg==\\n\",\n+      \"text/plain\": [\n+       \"<Figure size 432x288 with 1 Axes>\"\n+      ]\n+     },\n+     \"metadata\": {},\n+     \"output_type\": \"display_data\"\n+    }\n+   ],\n+   \"source\": [\n+    \"for tel_ in ['LST', 'MSTN', 'SST1', 'MSTF', 'MSTS', 'SSTC', 'SSTA', 'VTS']:\\n\",\n+    \"    print(tel_)\\n\",\n+    \"    fig, ax = plt.subplots(1)\\n\",\n+    \"    ax.set_aspect(1)\\n\",\n+    \"    ax.pcolor(test_im_dict[tel_][:,:,0],cmap='viridis')\\n\",\n+    \"    plt.show()\\n\",\n+    \"\\n\",\n+    \"\\n\"\n+   ]\n+  },\n+  {\n+   \"cell_type\": \"code\",\n+   \"execution_count\": null,\n+   \"metadata\": {\n+    \"collapsed\": true\n+   },\n+   \"outputs\": [],\n+   \"source\": []\n+  }\n+ ],\n+ \"metadata\": {\n+  \"kernelspec\": {\n+   \"display_name\": \"Python [default]\",\n+   \"language\": \"python\",\n+   \"name\": \"python3\"\n+  },\n+  \"language_info\": {\n+   \"codemirror_mode\": {\n+    \"name\": \"ipython\",\n+    \"version\": 3\n+   },\n+   \"file_extension\": \".py\",\n+   \"mimetype\": \"text/x-python\",\n+   \"name\": \"python\",\n+   \"nbconvert_exporter\": \"python\",\n+   \"pygments_lexer\": \"ipython3\",\n+   \"version\": \"3.5.1\"\n+  }\n+ },\n+ \"nbformat\": 4,\n+ \"nbformat_minor\": 1\n+}\n", "problem_statement": "", "hints_text": "", "created_at": "2018-06-02T02:39:25Z"}