Example #1
0
 def trumpet_plot(self, scan_rates, trumpets, **kwargs):
     if "ax" not in kwargs:
         ax = None
     else:
         ax = kwargs["ax"]
     if "label" not in kwargs:
         label = None
     else:
         label = kwargs["label"]
     if "description" not in kwargs:
         kwargs["description"] = False
     else:
         label = None
     if "log" not in kwargs:
         kwargs["log"] = np.log10
     if len(trumpets.shape) != 2:
         raise ValueError(
             "For plotting reductive and oxidative sweeps together")
     else:
         colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
         if ax == None:
             plt.scatter(kwargs["log"](scan_rates),
                         trumpets[:, 0],
                         label="Forward sim",
                         color=colors[0])
             plt.scatter(kwargs["log"](scan_rates),
                         trumpets[:, 1],
                         label="Reverse sim",
                         color=colors[0],
                         facecolors='none')
             plt.legend()
             plt.show()
         else:
             if kwargs["description"] == False:
                 if ax.collections:
                     pass
                 else:
                     self.color_counter = 0
                 ax.scatter(kwargs["log"](scan_rates),
                            trumpets[:, 0],
                            label=label,
                            color=colors[self.color_counter])
                 ax.scatter(kwargs["log"](scan_rates),
                            trumpets[:, 1],
                            color=colors[self.color_counter],
                            facecolors='none')
                 self.color_counter += 1
             else:
                 ax.scatter(kwargs["log"](scan_rates),
                            trumpets[:, 0],
                            label="$E_{p(ox)}-E^0$",
                            color=colors[0])
                 ax.scatter(kwargs["log"](scan_rates),
                            trumpets[:, 1],
                            label="$E_{p(red)}-E^0$",
                            color=colors[0],
                            facecolors='none')
Example #2
0
def plot_embeddings(embeddings,):
    X, Y = read_node_label('../data/wiki_labels.txt')

    emb_list = []
    for k in X:
        emb_list.append(embeddings[k])
    emb_list = np.array(emb_list)

    model = TSNE(n_components=2)
    node_pos = model.fit_transform(emb_list)

    color_idx = {}
    for i in range(len(X)):
        color_idx.setdefault(Y[i][0], [])
        color_idx[Y[i][0]].append(i)

    for c, idx in color_idx.items():
        plt.scatter(node_pos[idx, 0], node_pos[idx, 1], label=c)
    plt.legend()
    plt.show()
model.add(Flatten())
model.add(Dense(100))
model.add(Dropout(0.5))
model.add(Dense(50))
model.add(Dropout(0.5))
model.add(Dense(10))
#model.add(Dropout(0.5))
model.add(Dense(1))

model.compile(loss='mse', optimizer='adam')

history_object = model.fit(X_train,
                           y_train,
                           batch_size=32,
                           nb_epoch=8,
                           shuffle=True,
                           verbose=1,
                           validation_split=0.1)

model.save('model.h5')

from matplotlib.pyplot import plt
print(history_object.history.keys())

plt.plot(history_object.history['loss'])
plt.plot(history_object.history['val_loss'])
plt.title('model mean squared error loss')
plt.ylabel('mean squared error loss')
plt.xlabel('epoch')
plt.legend(['training set', 'validation set'], loc='upper right')
plt.show()
Example #4
0
# Plot each component overlayed on each other.

import numpy as np
import matplotlib.pyplot.plt

def square_copmonent(x, omega, k):
    """returns kth term frm square_wave aprxmtn"""
    return (4.0/np.pi) * np.sin(2*np.pi * (2*k-1) * omega*x) / (2*k-1)

x = np.linspace(0, 1, 500)
y = np.zeros((5, len(x))

for k in range(5):
    y[k,:] = square_component(x, 2, k+1)
    plt.plot(x, y[k,:], label = 'k=' + str(k+1))
plt.legend()
plt.show()

# Staff Soln:
# import numpy as np
# import matplotlib.pyplot as plt
# def square_component(x,omega,k):
#     val = (4.0/np.pi)* np.sin(2*np.pi*(2*k-1)*omega*x)/(2*k-1)
#     return val
#
# omega=2
# x = np.linspace(0,1,500)
# ks = [1,2,3,4,5]
# y = np.zeros((5,len(x)))
#
# for indx,k in enumerate(ks):
Example #5
0
    def k0_interpoltation(self, scans, trumpet, **units):
        scan_rates = np.log(scans)
        anodic_sweep = trumpet[:, 0]
        cathodic_sweep = trumpet[:, 1]
        data = [anodic_sweep, cathodic_sweep]
        if "T" not in units:
            units["T"] = 278
        if "n" not in units:
            units["n"] = 1
        if "E_0" not in units:

            units["E_0"] = (anodic_sweep[-1] - cathodic_sweep[-1]) / 2
            print(units["E_0"])
        if "deviation" not in units:
            deviation = 100
        else:
            deviation = units["deviation"]
        if "plot" not in units:
            units["plot"] = False
        else:
            if "ax" not in units:
                units["ax"] = None
                fig, ax = plt.subplots(1, 1)
            else:
                ax = units["ax"]
        units["F"] = 96485.3329
        units["R"] = 8.31446261815324
        nF = units["n"] * units["F"]
        RT = units["R"] * units["T"]
        difference = self.square_error(anodic_sweep, cathodic_sweep)
        mean_low_scans = np.mean(difference[:5])
        low_scan_deviation = np.divide(difference, mean_low_scans)
        start_scan = tuple(np.where(low_scan_deviation > deviation))
        inferred_k0 = [0 for x in range(0, len(data))]
        for i in range(0, len(data)):
            fitting_scan_rates = scan_rates[start_scan]
            fitting_data = np.subtract(data[i][start_scan], units["E_0"])
            popt, _ = curve_fit(self.poly_1, fitting_scan_rates, fitting_data)
            m = popt[0]

            c = popt[1]
            #print(m,c)
            if i == 0:
                alpha = 1 - ((RT) / (m * nF))
                exp = np.exp(c * nF * (1 - alpha) / (RT))
                inferred_k0[i] = (nF * (1 - alpha)) / (RT * exp)
            else:
                alpha = -((RT) / (m * nF))
                exp = np.exp(c * nF * (-alpha) / (RT))
                inferred_k0[i] = (nF * (alpha)) / (RT * exp)
            fitted_curve = [self.poly_1(t, *popt) for t in fitting_scan_rates]
            if units["plot"] == True:
                if i == 0:
                    ax.plot(fitting_scan_rates,
                            fitted_curve,
                            color="red",
                            label="Linear region")
                else:
                    ax.plot(fitting_scan_rates, fitted_curve, color="red")
        if units["plot"] == True:
            self.trumpet_plot(scans,
                              np.column_stack((data[0] - units["E_0"],
                                               data[1] - units["E_0"])),
                              ax=ax,
                              log=np.log,
                              description=True)
            plt.legend()
            fig = plt.gcf()
            fig.set_size_inches(7, 4.5)
            plt.show()
            fig.savefig("DCV_trumpet_demonstration.png", dpi=500)
        return inferred_k0
    batch_size=batch_size,
    epochs=epochs,
    #verbose=1,
    callbacks=[cb],
    validation_split=.1,
    #validation_data=(X_test, y_test)
)
score = model.evaluate(X_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

predicted = model.predict(X_test, verbose=False)
predicted = np.argmax(predicted, axis=1)

from keras.utils import plot_model
plot_model(model, to_file='CNN.png')

#CM = ConfusionMatrix(predicted, y_test_orig, c);
#np.savetxt("data/CNN_predicted_raw.txt", predicted, "%d")
#np.savetxt("data/CNN_cm_raw.txt", CM, "%d");

from matplotlib.pyplot import plt

plt.plot(history.history['val_acc'])
plt.plot(history.history['acc'])
plt.legend(['Validation Accuracy', 'Training Accuracy'])
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.title('CNN Convergence Curve')
plt.show()