Captcha recognizer

def create_layer(layer_size, input_size, sigma_function=lambda val:val):
    from random import random
    return (
            [
                [
                    [
                        [random() for w in range(input_size)]
                        for x in range(layer_size)
                    ],
                    0,
                    sigma_function
                ]
            ]
            )

def pass_data(data_in, data_thru):
    from functools import reduce
    from itertools import repeat

    if not len(data_thru):
        return data_in
    in_len = len(data_thru[0][0])
    if len(data_in) != in_len:
        return data_in

    return (
        reduce(
            lambda data, layer: (
                [
                    sigma(
                        sum(
                            (val*mul+bias for val, mul in zip(data, weights))
                            ) /
                        len(weights)
                        )
                    for weights, bias, sigma in zip(layer[0], repeat(layer[1]), repeat(layer[2]))
                ]
            ),
            data_thru,
            data_in
            )
        )

def error_function(interval_set):
    from itertools import combinations

    def intersection_coeff(interval_a, interval_b):
        best_min = max(interval_a[0], interval_b[0])
        best_max = min(interval_a[1], interval_b[1])
        least_len = min(interval_a[1]-interval_a[0],
                        interval_b[1]-interval_b[0])

        intersection = ((best_min, best_min)
                        if best_min >= best_max
                        else (best_min, best_max))

        full_len = intersection[1] - intersection[0]
        return full_len / least_len

    def intersection_cost(cost):
        return cost**2

    pipe = lambda inter_pair: intersection_cost(intersection_coeff(inter_pair[0], inter_pair[1]))
    all_combinations = combinations(interval_set, 2)
    intersections = map(pipe, all_combinations)
    return sum(intersections)