示例#1
0
 def _get_fpt_ell_collection(dm, fpts, T_data, alpha, edgecolor):
     ell_patches = []
     for (x, y, a, c, d) in fpts:  # Manually Calculated sqrtm(inv(A))
         with catch_warnings():
             simplefilter("ignore")
             aIS = 1 / sqrt(a)
             cIS = (c / sqrt(a) - c / sqrt(d)) / (a - d + eps(1))
             dIS = 1 / sqrt(d)
         transEll = Affine2D([(aIS, 0, x), (cIS, dIS, y), (0, 0, 1)])
         unitCirc1 = Circle((0, 0), 1, transform=transEll)
         ell_patches = [unitCirc1] + ell_patches
     ellipse_collection = PatchCollection(ell_patches)
     ellipse_collection.set_facecolor("none")
     ellipse_collection.set_transform(T_data)
     ellipse_collection.set_alpha(alpha)
     ellipse_collection.set_edgecolor(edgecolor)
     return ellipse_collection
示例#2
0
 def _get_fpt_ell_collection(dm, fpts, T_data, alpha, edgecolor):
     ell_patches = []
     for (x,y,a,c,d) in fpts: # Manually Calculated sqrtm(inv(A))
         with catch_warnings():
             simplefilter("ignore")
             aIS = 1/sqrt(a)
             cIS = (c/sqrt(a) - c/sqrt(d))/(a - d + eps(1))
             dIS = 1/sqrt(d)
         transEll = Affine2D([\
                 ( aIS,   0,   x),\
                 ( cIS, dIS,   y),\
                 (   0,   0,   1)])
         unitCirc1 = Circle((0,0),1,transform=transEll)
         ell_patches = [unitCirc1] + ell_patches
     ellipse_collection = PatchCollection(ell_patches)
     ellipse_collection.set_facecolor('none')
     ellipse_collection.set_transform(T_data)
     ellipse_collection.set_alpha(alpha)
     ellipse_collection.set_edgecolor(edgecolor)
     return ellipse_collection
示例#3
0
 def build_model(vm, force_recomp=False):
     ''' Builds the model, if needed. Tries to reload if it can '''
     logmsg('\n\nRequested: Build Model')
     if not force_recomp and not vm.isDirty:
         logmsg('The model is clean and is not forced to recompute')
         return True
     cm = vm.hs.cm
     # Delete old index and resample chips to index
     vm.delete_model()
     vm.sample_train_set()
     # Try to load the correct model
     if not force_recomp and vm.load_model():
         logmsg('Loaded saved model from disk')
         return
     logmsg('Building the model. This may take some time.')
     # Could not load old model. Do full rebuild
     # -----
     # STEP 1 - Loading
     logdbg('Step 1: Aggregate the model support (Load feature vectors) ---')
     tx2_cx   = vm.get_train_cx()
     tx2_cid  = vm.get_train_cid()
     assert len(tx2_cx) > 0, 'Training set cannot be  np.empty'
     logdbg('Building model with %d sample chips' % (vm.num_train()))
     cm.load_features(tx2_cx)
     tx2_nfpts = cm.cx2_nfpts(tx2_cx)
     num_train_keypoints = sum(tx2_nfpts)
     # -----
     # STEP 2 - Aggregating 
     logdbg('Step 2: Build the model Words')
     isTFIDF = False
     if vm.hs.am.algo_prefs.model.quantizer == 'naive_bayes':
         logdbg('No Quantization. Aggregating all fdscriptors for nearest neighbor search.')
         vm.wx2_fdsc = np.empty((num_train_keypoints,128),dtype=np.uint8)
         _p = 0
         for cx in tx2_cx:
             nfdsc = cm.cx2_nfpts(cx)
             vm.wx2_fdsc[_p:_p+nfdsc,:] = cm.cx2_fdsc[cx]
             _p += nfdsc
         ax2_wx = np.array(range(0,num_train_keypoints),dtype=np.uint32)
     if vm.hs.am.algo_prefs.model.quantizer == 'akmeans':
         raise NotImplementedError(':)')
     # -----
     # STEP 3 - Inverted Indexing
     logdbg('Step 3: Point the parts of the model back to their source')
     vm.wx2_axs = np.empty(vm.wx2_fdsc.shape[0], dtype=object) 
     for ax in xrange(0,num_train_keypoints):
         if vm.wx2_axs[ax] is None:
             vm.wx2_axs[ax] = []
         wx = ax2_wx[ax]
         vm.wx2_axs[wx].append(ax)
     vm.ax2_cid = -np.ones(num_train_keypoints,dtype=np.int32) 
     vm.ax2_fx  = -np.ones(num_train_keypoints,dtype=np.int32)
     ax2_tx     = -np.ones(num_train_keypoints,dtype=np.int32)
     curr_fx = 0; next_fx = 0
     for tx in xrange(vm.num_train()):
         nfpts    = tx2_nfpts[tx]
         next_fx  = next_fx + nfpts
         ax_range = range(curr_fx,next_fx)
         ax2_tx[ax_range] = tx
         vm.ax2_cid[ax_range] = tx2_cid[tx]    # Point to Inst
         vm.ax2_fx[ax_range]  = range(nfpts)   # Point to Kpts
         curr_fx = curr_fx + nfpts
     if isTFIDF: # Compute info for TF-IDF
         logdbg('Computing TF-IDF metadata')
         max_tx = len(tx2_cx)
         tx2_wtf_denom = np.float32(cm.cx2_nfpts(tx2_cx))
         vm.wx2_maxtf = map(lambda ax_of_wx:\
             max( np.float32(bincount(ax2_tx[ax_of_wx], minlength=max_tx)) / tx2_wtf_denom ), vm.wx2_axs)
         vm.wx2_idf = np.log2(map(lambda ax_of_wx:\
             vm.num_train()/len(pylab.unique(ax2_tx[ax_of_wx])),\
             vm.wx2_axs)+eps(1))
     logdbg('Built Model using %d feature vectors. Preparing to index.' % len(vm.ax2_cid))
     # -----
     # STEP 4 - Indexing
     logdbg('Step 4: Building FLANN Index: over '+str(len(vm.wx2_fdsc))+' words')
     assert vm.flann is None, 'Flann already exists'
     vm.flann = FLANN()
     flann_param_dict = vm.hs.am.algo_prefs.model.indexer.to_dict()
     flann_params = vm.flann.build_index(vm.wx2_fdsc, **flann_param_dict)
     vm.isDirty  = False
     vm.save_model()
     logmsg('The model was built.')
示例#4
0
文件: hull.py 项目: tartaruszen/ARSpy
def compute_hulls(S, fS, domain):
    """
    (Re-)compute upper and lower hull given
    the segment points `S` with function values
    `fS` and the `domain` of the logpdf.

    Parameters
    ----------
    S : np.ndarray (N, 1)
       Straight-line segment points accumulated thus far.

    fS : tuple
        Value of the `logpdf` under sampling for each
        of the given segment points in `S`.

    domain : Tuple[float, float]
        Domain of `logpdf`.
        May be unbounded on either or both sides,
        in which case `(float("-inf"), float("inf"))`
        would be passed.
        If this domain is unbounded to the left,
        the derivative of the logpdf
        for x<= a must be positive.
        If this domain is unbounded to the right                  the derivative of the logpdf for x>=b
        must be negative.

    Returns
    ----------
    lower_hull: List[arspy.hull.HullNode]
    upper_hull: List[arspy.hull.HullNode]

    """
    assert (len(S) == len(fS))
    assert (len(domain) == 2)

    lower_hull = []

    for li in range(len(S) - 1):
        m = (fS[li + 1] - fS[li]) / (S[li + 1] - S[li])
        b = fS[li] - m * S[li]
        left = S[li]
        right = S[li + 1]
        lower_hull.append(HullNode(m=m, b=b, left=left, right=right))

    # compute upper piecewise-linear hull

    # expected final length of upper hull after full computation
    n_upper_segments = 2 * (len(S) - 2) + isinf(domain[0]) + isinf(domain[1])

    upper_hull = []

    if isinf(domain[0]):
        # first line (from -infinity)

        m = (fS[1] - fS[0]) / (S[1] - S[0])
        b = fS[0] - m * S[0]
        pr = compute_segment_log_prob(float("-inf"), S[0], m, b)

        upper_hull.append(
            HullNode(m=m, b=b, pr=pr, left=float("-inf"), right=S[0]))

    # second line
    m = (fS[2] - fS[1]) / (S[2] - S[1])
    b = fS[1] - m * S[1]
    pr = compute_segment_log_prob(S[0], S[1], m, b)

    upper_hull.append(HullNode(m=m, b=b, pr=pr, left=S[0], right=S[1]))

    # interior lines
    # there are two lines between each abscissa
    for li in range(1, len(S) - 2):

        m1 = (fS[li] - fS[li - 1]) / (S[li] - S[li - 1])
        b1 = fS[li] - m1 * S[li]

        m2 = (fS[li + 2] - fS[li + 1]) / (S[li + 2] - S[li + 1])
        b2 = fS[li + 1] - m2 * S[li + 1]

        if isinf(m1) and isinf(m2):
            raise ValueError("both hull slopes are infinite")

        dx1 = S[li] - S[li - 1]
        df1 = fS[li] - fS[li - 1]
        dx2 = S[li + 2] - S[li + 1]
        df2 = fS[li + 2] - fS[li + 1]

        f1 = fS[li]
        f2 = fS[li + 1]
        x1 = S[li]
        x2 = S[li + 1]

        # more numerically stable than above
        ix = ((f1 * dx1 - df1 * x1) * dx2 -
              (f2 * dx2 - df2 * x2) * dx1) / (df2 * dx1 - df1 * dx2)

        if isinf(m1) or abs(m1 - m2) < 10.0**8 * eps(m1):
            ix = S[li]
            pr1 = float("-inf")
            pr2 = compute_segment_log_prob(ix, S[li + 1], m2, b2)
        elif isinf(m2):
            ix = S[li + 1]
            pr1 = compute_segment_log_prob(S[li], ix, m1, b1)
            pr2 = float("-inf")
        else:
            if isinf(ix):
                raise ValueError("Non finite intersection")

            if abs(ix - S[li]) < 10.0**12 * eps(S[li]):
                ix = S[li]
            elif abs(ix - S[li + 1]) < 10.0**12 * eps(S[li + 1]):
                ix = S[li + 1]

            if ix < S[li] or ix > S[li + 1]:
                raise ValueError(
                    "Intersection out of bounds -- logpdf is not concave")

            pr1 = compute_segment_log_prob(S[li], ix, m1, b1)
            pr2 = compute_segment_log_prob(ix, S[li + 1], m2, b2)

            upper_hull.append(
                HullNode(m=m1, b=b1, pr=pr1, left=S[li], right=ix))
            upper_hull.append(
                HullNode(m=m2, b=b2, pr=pr2, left=ix, right=S[li + 1]))

    # second last line
    m = (fS[-2] - fS[-3]) / float(S[-2] - S[-3])
    b = fS[-2] - m * S[-2]
    pr = compute_segment_log_prob(S[-2], S[-1], m, b)

    upper_hull.append(HullNode(m=m, b=b, pr=pr, left=S[-2], right=S[-1]))

    if isinf(domain[1]):
        # last line (to infinity)
        m = (fS[-1] - fS[-2]) / (S[-1] - S[-2])
        b = fS[-1] - m * S[-1]
        pr = compute_segment_log_prob(S[-1], float("inf"), m, b)

        upper_hull.append(
            HullNode(m=m, b=b, pr=pr, left=S[-1], right=float("inf")))

    # normalize probabilities
    normalized_probabilities = exp_normalize(
        asarray([node.pr for node in upper_hull]))

    for node, probability in zip(upper_hull, normalized_probabilities):
        node.pr = probability

    assert (len(lower_hull) == len(S) - 1)
    assert (len(upper_hull) == n_upper_segments)

    return lower_hull, upper_hull
示例#5
0
def elu(param, x):
    return param * (np.eps(x) - 1.) if x < 0 else x