def loadSSFPdata(loadSSFPpaths, loadT1path, loadT2path):

    ## Load T1
    T1_img = np.array(nrrd.read(loadT1path)[0])

    ## Load T2
    T2_img = np.array(nrrd.read(loadT2path)[0])

    ## Load SSFP
    numSSFP = len(loadSSFPpaths)
    SSFP_files = range(numSSFP)
    SSFP_shape = range(numSSFP)
    for ss in range(numSSFP):
        print('Loading file: ' + loadSSFPpaths[ss])
        SSFP_files[ss] = np.rray(nrrd.read(loadSSFPpaths[ss])[0])
        SSFP_shape = SSFP_files[ss].shape

    return SSFP_files, T1_img, T2_img
def plot_decision_boundry(X,y):
	X_set,y_set = X,y
	import matplotlib.pyplot as plt
	from matplotlib.colors import ListedColormap
	X1,X2 = np.meshgrid(np.arange(start = X_set[:,0].min()-1, stop=X_set[:,0].max()+1, step=0.01),
		np.arange(start=X_set[:,1].min()-1, stop=X_set[:,1].max()+1, step=0.01)
		)
	plt.contour(X1,X2,clf.predict(np.rray([X1.ravel(),X2.ravel()]).T ).reshape(X1.shape),alpha=0.75)
	plt.xlim(X1.min(),X1.max())
	plt.ylim(X2.min(),X2.max())
	for i,j in enumerate(np.unique(y_set)):
		plt.scatter(X_set[y_set==j,0], X_set[y_set==j,1], c=ListedColormap(('red','green'))(i),label=j)

	plt.title('Logistic Regression Classification Boundry')
	plt.xlabel('X Label')
	plt.ylabel('Y Label')
	plt.legend()
	plt.show()
Esempio n. 3
0
def DOER(N0, nHiddenNeurons, Block, nModels, alfa, windowSize, dataset,
         trBlock):
    ##### Load dataset
    try:
        data = np.genfromtxt(dataSet, dtype=float)
    except Exception:
        print('An error ecurred while loading data')

    T = np.array(data[:, 0])
    P = np.rray(data[:, 1:data.shape[1]])

    nInputNeurons = data.shape[1] - 1
    nTrainingData = data.shape[0]

    ##### Step 1 Initialization Phase
    P0 = P[0:N0, :]
    T0 = T[0:N0]

    PT = np.array(P[N0 - trBlock:nTrainingData, :])
    TT = np.array(T[N0 - trBlock:nTrainingData])
    Real = np.array(T[N0 - 1:nTrainingData - 1])
    Y = np.zeros_like(Real)
    Error = np.zeros_like(Real)

    start_time = time()
    errorSum = 0
    ensemble = []
    ensemOutput = []

    ensemble.append(trainModel(nHiddenNeurons, nInputNeurons, P0, T0))

    nModelsCounter = 0

    ##### Step 2 Sequential Learning Phase
    for n in range(trBlock, PT.shape[0]):

        Ptemp1 = np.array(PT[(n - windowSize):n])
        Ttemp1 = np.array(TT[(n - windowSize):n])
        #        print("Ptemp1: ", Ptemp1, "Ttemp1: ", Ttemp1)
        SumW = 0
        SumYW = 0

        for modl in ensemble:
            H = SigActFun(modl.Bias, Ptemp1, modl.IW)

            g = np.dot(H, modl.beta)

            if nModelsCounter < 11:
                ensemOutput.append(g[-1])
                SumW += modl.w
                SumYW += g[-1] * modl.w
                nModelsCounter += 1

            modl.calculateError(g[-1], Ttemp1[-1], trBlock)
            modl.calculateMSE(trBlock)
            modl.calculateWeight(ensemble)

            K = np.dot(modl.M, np.transpose(H))
            Q = np.linalg.inv(np.eye(windowSize) + np.dot(H, K))
            R = np.dot(K, Q)
            S = np.dot(H, modl.M)
            M = modl.M - np.dot(R, S)

            beta = modl.beta + np.dot(np.dot(M, np.transpose(H)),
                                      (Ttemp1 - np.dot(H, modl.beta)))
            modl.beta = beta
            modl.M = M

        nModelsCounter = 0
        modelObj.rank(ensemble)
        Y[n - trBlock] = SumYW / SumW
        #        print("Y: ", (n-60), "n: ",n, "Y[n-60]: ",Y[n-60])
        ensemOutput = []

        errorSum += np.power((Ttemp1[-1] - Y[n - trBlock]), 2)
        Error[n - trBlock] = errorSum / ((n - trBlock) + 1)

        if Ttemp1[-1] != 0:
            a = abs(Y[n - trBlock] - Ttemp1[-1] / Ttemp1[-1])

        if a > alfa:
            Ptemp2 = np.array(PT[(n - trBlock):n])
            Ttemp2 = np.array(TT[(n - trBlock):n])
            newModel = trainModel(nHiddenNeurons, nInputNeurons, Ptemp2,
                                  Ttemp2)

            if len(ensemble) < nModels:
                ensemble.append(newModel)

            else:
                ensemble = modelObj.replaceModels(ensemble, newModel)

    ##### Time in seconds
    end_time = time()
    totalTime = end_time - start_time
    hours, rest = divmod(totalTime, 3600)
    minutes, seconds = divmod(rest, 60)
    compTime = np.round(seconds, 5)
    ##### Acurracy MSE
    mse = mean_squared_error(Real, Y)
    accuracy = np.round(mse, 5)

    last_Real = Real[-200:]
    last_Y = Y[-200:]
    last_accuracy = mean_squared_error(last_Real, last_Y)
    return accuracy, compTime, Error, last_accuracy
Esempio n. 4
0
model.fit(corr_whisky)
print(model.rows_)
print(np.sum(model.rows_, axis=1))
print(np.sum(model.rows_, axis=0))  #1's
print(model.row_labels_)  #observation index belongs to cluster 0-5

#Comparing Correlation Matrices
#Rename indices to match sorting
#Append group labels from model to whisky table
whisky['Group'] = pd.Series(model.row_labels_, index=whisky.index)
#Reorder rows by increasing group order from spectral coclustering
whisky = whisky.ix[np.argsort(
    model.row_labels_)]  #changes appearance but leaves indices same
#Reset index of dataframe
whisky = whisky.reset_index(drop=True)  #resets indices in increasing order

correlations = pd.DataFrame.corr(whisky.iloc[:, 2:14].T)
correlations = np.rray(correlations)

plt.figure(figsize=(14, 7))
plt.subplot(121)
plt.pcolor(corr_whisky)
plt.title("Original")
plt.axis("tight")
plt.subplot(122)
plt.pcolor(correlations)
plt.title("Rearranged")
plt.axis("tight")
plt.savefig("correlations.pdf")
#see 6 blocks of whiskies along line , similar flavors
Esempio n. 5
0
def vertex_find(A, b, lb, ub):
    if len(lb) != 0:
        Vertex = np.matrix([[], []])
        m = A.shape[0]
        n = A.shape[1]
        if m == 0:
            Vertex = bounds(lb, ub, len(lb))
        else:
            for r in range(0, min(n, m) + 1):
                from itertools import combinations
                C = [c for c in combinations(range(1, m + 1), r)]
                C = [list(c) for c in C]
                D = [d for d in combinations(range(1, n + 1), n - r)]
                D = [list(d) for d in D]
                if r == 0:
                    F = np.array(bounds(lb, ub, n))
                    for kk in range(F.shape[1]):
                        x = np.copy(F[:, kk]).reshape(-1, 1)
                        if (np.dot(A, x) - b).min() < 1e-6:
                            Vertex = np.column_stack((Vertex, x))
                else:
                    for ii in range(len(C)):
                        index_A = np.copy(list(C[ii]))
                        print index_A
                        v1 = [i for i in range(1, m + 1)]
                        index_A_C = np.setdiff1d(v1, index_A)
                        A1 = np.copy(A[index_A - 1, :])
                        b1 = np.copy(b[index_A - 1])
                        for jj in range(len(D)):
                            index_B = np.copy(list(D[jj]))
                            v2 = [i for i in range(1, n + 1)]
                            index_B_C = np.setdiff1d(v2, index_B)
                            F = bounds(lb[index_B - 1], ub[index_B - 1], n - r)
                            A11 = np.copy(A1[:, index_B - 1])
                            A12 = np.copy(A1[:, index_B_C - 1])
                            for kk in range(F.shape[1]):
                                A11 = np.copy(A1[:, index_B - 1])
                                A12 = np.copy(A1[:, index_B_C - 1])
                                xd = np.linalg.inv(A12) * (b1 - A11 * F[:, kk])
                                x = np.zeros((2)).reshape(-1, 1)
                                x[index_B - 1] = F[:, kk]
                                x[index_B_C - 1] = xd
                                if r == m or (np.dot(A[index_A_C - 1, :], x) -
                                              b[index_A_C - 1]).min() < 0:
                                    [y, x1, index] = mindis(x, Vertex)

                                    if (x - ub).max() < 1e-6 and (
                                            x - lb).min() > -1e-6 and y > 1e-6:
                                        Vertex = np.column_stack((Vertex, x))
                                        # Vertex = np.concatenate((Vertex, x),axis = 1)
                                        # print('------------!!!!-----------')
                                        # print(y)
                                        # print(x1)
                                        # print(index)
                                        print('--------------!!!!---------')
                                        quit()
    else:
        m = A.shape[0]
        n = A.shape[1]
        from itertools import combinations
        C = [c for c in combinations(range(1, m), n)]
        C = [list(c) for c in C]
        Vertex = list()
        for ii in range(len(C)):
            index_A = np.copy(list(C[ii]))
            v1 = [i for i in range(1, m + 1)]
            index_A_C = np.setdiff1d(v1, index_A)
            A1 = np.copy(A[index_A - 1, :])
            b1 = np.copy(b[index_A - 1])
            A2 = np.copy(A[index_A_C - 1])
            b2 = np.copy(b[index_A_C - 1])
            x = np.rray(np.linalg.inv(A1) * b1)
            if (A2 * x - b2).max() < 1e-6:
                Vertex = np.column_stack((Vertex, x))
    return Vertex