def isentrope(self, S): if self.S == S: return self.S = S # Make array of v values. To be independent variable for ode # and splines. dv = (self.v_max - self.v_min)/1000 v = np.arange(self.v_min-dv, self.v_max+1.5*dv, dv) # Allocate array for dependent variables PE = np.empty((2,len(v))) # Find initial state variables for ode v_1 = 1/self.rhoCJ E_1 = self.E_0*np.exp((S-self.S_0)/self.cv) P_1 = self.Ev2P(E_1, v_1) i_1 = np.searchsorted(v,[v_1])[0] # v[i_1-1] < v_1 < v[i_1] self.ode.set_initial_value([P_1,E_1],v_1) for i in range(i_1,len(v)): self.ode.integrate(v[i]) PE[:,i] = self.ode.y self.ode.set_initial_value([P_1,E_1],v_1) for i in range(i_1-1,-1,-1): self.ode.integrate(v[i]) PE[:,i] = self.ode.y from scipy.interpolate import InterpolatedUnivariateSpline as spline self.isentrope_v2E = spline(v,PE[1],k=3,s=0) self.isentrope_E2v = spline(PE[1,-1::-1],v) self.isentrope_P2v = spline(PE[0,-1::-1],v) return
def draw_CV_on_window_center(): x_ecg = np.array([-0.415263158, -0.336315789, -0.257368421, -0.178421053, -0.099473684, -0.035957895, -0.020526316, -0.015784211, 0.0, 0.036094737, 0.059157895, 0.069473684, 0.103842105, 0.188842105, 0.249368421, 0.373315789, 0.442473684, 0.468421053, 0.531842105, 0.576526316, 0.584736842, 0.648421053]) y_ecg = np.array([-1414, -1738, -333, -1846, -981, 2585, 11990, 14476, 22367, 16746, 5720, -4333, -10386, -2819, -3143, -766, 3342, 3882, 1504, -1954, -2170, -2063]) x_ecg_new = np.linspace(np.min(x_ecg), np.max(x_ecg), len(x_ecg) * 5) y_ecg_new = spline(x_ecg, y_ecg, x_ecg_new) x_CV = np.array(np.linspace(-0.475, 0.525, 41)) # y_CV = [0.8811, 0.8757, 0.8649, 0.7838, 0.6595, 0.5297, 0.6054, 0.6270, 0.6378, 0.6270, 0.6486, 0.6378, 0.6378, 0.6216, 0.5892, 0.6324, 0.7027, 0.7243, 0.7351, 0.7351, 0.7081, 0.7135, 0.6270, 0.6270, 0.6486, 0.6486, 0.6378, 0.6216, 0.6000, 0.6270, 0.7892, 0.8270, 0.8378, 0.8054, 0.7405, 0.7297, 0.6541, 0.6811, 0.8378, 0.8595] y_CV = np.array([0.7135, 0.627, 0.627, 0.6486, 0.6486, 0.6378, 0.6216, 0.6, 0.627, 0.7892, 0.827, 0.8378, 0.8054, 0.7405, 0.7297, 0.6541, 0.6811, 0.8378, 0.8595, 0.8811, 0.8757, 0.8649, 0.7838, 0.6595, 0.5297, 0.6054, 0.627, 0.6378, 0.627, 0.6486, 0.6378, 0.6378, 0.6216, 0.5892, 0.6324, 0.7027, 0.7243, 0.7351, 0.7351, 0.7081, 0.7135]) x_CV_new = np.linspace(np.min(x_CV), np.max(x_CV), len(x_CV) * 5) y_CV_new = spline(x_CV, y_CV, x_CV_new) fig, ax1 = plt.subplots() ax1.plot(x_ecg / 6, y_ecg / float(0.8 * np.max(y_ecg)), 'k-', linewidth=2.) ax1.set_xlabel(u'Время, сек') ax1.set_ylabel(u'Интенсивность', color='k') for tl in ax1.get_yticklabels(): tl.set_color('k') ax2 = ax1.twinx() # ax2.plot(x_CV_new / 6, y_CV_new, 'r-', linewidth=2.) ax2.plot(x_CV / 6, y_CV, 'r-', linewidth=2.) ax2.plot(x_CV / 6, y_CV, 'r^') plt.ylim([0.1, 1.0]) ax2.set_ylabel(u'Оценка 5х5-fold кросс-валидации', color='r') for tl in ax2.get_yticklabels(): tl.set_color('r') plt.grid(True) # plt.show() plt.savefig(r'..\..\logs\CV_on_window_center.png')
def prepare_mf(mpart, grid, mf_kwargs): M = np.linspace(np.log10(mpart), np.log10(grid.max()), 2000) mf_obj = MassFunction(M=M, **mf_kwargs) mf = mf_obj.dndm m_outside_range = mf_obj.mltm[0] + mf_obj.mgtm[-1] cumfunc = cumtrapz(10 ** M * mf, M, initial=0) * np.log(10) cdf = spline(M, cumfunc, k=3) icdf = spline(cumfunc, M, k=3) if MAKE_PLOTS: plt.clf() plt.plot(M, cumfunc) plt.plot(M, cdf(M)) plt.savefig("cumfunc.pdf") plt.clf() mcumfunc = cumtrapz(10 ** (2 * M) * mf, dx=M[1] - M[0], initial=1e-20) * np.log(10) plt.plot(M, mcumfunc) plt.savefig("mcumfunc.pdf") # How much mass is above 10**12.5 minvcumfunc = cumtrapz(10 ** (2 * M[::-1]) * mf[::-1], dx=M[1] - M[0]) * np.log(10) minvcumfunc = np.concatenate((np.array([minvcumfunc[0]]), minvcumfunc)) minvcumfunc /= minvcumfunc[-1] plt.clf() plt.plot(M, minvcumfunc[::-1]) plt.yscale('log') plt.grid(True) plt.savefig("minvcumfunc.pdf") return cdf, icdf, M, mf, m_outside_range
def plot_word_graph(): global score_true,score_false accuracies = [] n_pure = [] data_size = [] fig, ax = plt.subplots() axes = [ax, ax.twinx()] for thr in range(1500,2500): print thr mixed = [] pure = [] threshold = float(thr)/1 for similiarity_index in score_true: if similiarity_index > thr: pure.append(1) else: mixed.append(0) for similiarity_index in score_false: if similiarity_index > thr: pure.append(0) else: mixed.append(1) accuracies.append(float(pure.count(1)*100)/len(pure)) n_pure.append(pure.count(1)) data_size.append(len(pure)) base = np.array([float(x)/1 for x in range(1500,2500)]) thr = np.linspace(base.min(),base.max(),2000) accuracies_smooth = spline(base,accuracies,thr) n_pure_smooth = spline(base,n_pure,thr) data_size_smooth = spline(base,data_size,thr) axes[1].plot(thr,accuracies_smooth,'r') axes[0].plot(thr,n_pure_smooth,'b') axes[0].plot(thr,data_size_smooth,'g') plt.show()
def _upper_ngtm(self, M, mass_function, cut): """Calculate the mass function above given range of `M` in order to integrate""" ### WE CALCULATE THE MASS FUNCTION ABOVE THE COMPUTED RANGE ### # mass_function is logged already (not log10 though) m_upper = np.linspace(np.log(M[-1]), np.log(10 ** 18), 500) if cut: # since its been cut, the best we can do is a power law mf_func = spline(np.log(M), mass_function, k=1) mf = mf_func(m_upper) else: # We try to calculate the hmf as far as we can normally new_pert = copy.deepcopy(self) new_pert.update(M=np.log10(np.exp(m_upper))) mf = np.log(np.exp(m_upper) * new_pert.dndm) if np.isnan(mf[-1]): # Then we couldn't get up all the way, so have to do linear ext. if np.isnan(mf[1]): # Then the whole extension is nan and we have to use the original (start at 1 because 1 val won't work either) mf_func = spline(np.log(M), mass_function, k=1) mf = mf_func(m_upper) else: mfslice = mf[np.logical_not(np.isnan(mf))] m_nan = m_upper[np.isnan(mf)] m_true = m_upper[np.logical_not(np.isnan(mf))] mf_func = spline(m_true, mfslice, k=1) mf[len(mfslice):] = mf_func(m_nan) return m_upper, mf
def read_adp_data(self, data, d): """reads in the extra data fro the adp format""" self.d_data = np.zeros([self.Nelements, self.Nelements, self.nr]) # should be non symetrical combinations of 2 for i in range(self.Nelements): for j in range(i, self.Nelements): self.d_data[i, j] = data[d:d + self.nr] d += self.nr self.q_data = np.zeros([self.Nelements, self.Nelements, self.nr]) # should be non symetrical combinations of 2 for i in range(self.Nelements): for j in range(i, self.Nelements): self.q_data[i, j] = data[d:d + self.nr] d += self.nr self.d = np.zeros([self.Nelements, self.Nelements], object) self.d_d = np.zeros([self.Nelements, self.Nelements], object) self.q = np.zeros([self.Nelements, self.Nelements], object) self.d_q = np.zeros([self.Nelements, self.Nelements], object) for i in range(self.Nelements): for j in range(i, self.Nelements): self.d[i, j] = spline(self.r[1:], self.d_data[i, j][1:], k=3) self.d_d[i, j] = self.deriv(self.d[i, j]) self.q[i, j] = spline(self.r[1:], self.q_data[i, j][1:], k=3) self.d_q[i, j] = self.deriv(self.q[i, j]) # make symmetrical if j != i: self.d[j, i] = self.d[i, j] self.d_d[j, i] = self.d_d[i, j] self.q[j, i] = self.q[i, j] self.d_q[j, i] = self.d_q[i, j]
def animate(cpu): x = range(50) cpuinfo_g = cpuinfo() y_load_l = cpuinfo_g.load_sum_l y_load_b = cpuinfo_g.load_sum_b y_freq_l = cpuinfo_g.freq_l y_freq_b = cpuinfo_g.freq_b x_sm = np.array(x) y_sm_ll = np.array(y_load_l) y_sm_lb = np.array(y_load_b) y_sm_fl = np.array(y_freq_l) y_sm_fb = np.array(y_freq_b) x_smooth = np.linspace(x_sm.min(), x_sm.max(), 200) y_smooth_load_l = spline(x, y_sm_ll, x_smooth) y_smooth_load_b = spline(x, y_sm_lb, x_smooth) y_smooth_freq_l = spline(x, y_sm_fl, x_smooth) y_smooth_freq_b = spline(x, y_sm_fb, x_smooth) cpulock.acquire() load_sum_l.set_data(x_smooth, y_smooth_load_l) load_sum_b.set_data(x_smooth, y_smooth_load_b) freq_l.set_data(x_smooth, y_smooth_freq_l) freq_b.set_data(x_smooth, y_smooth_freq_b) cpulock.release() return load_sum_l, load_sum_b, freq_l, freq_b
def set_splines(self): # this section turns the file data into three functions (and # derivative functions) that define the potential self.embedded_energy = np.empty(self.Nelements, object) self.electron_density = np.empty(self.Nelements, object) self.d_embedded_energy = np.empty(self.Nelements, object) self.d_electron_density = np.empty(self.Nelements, object) for i in range(self.Nelements): self.embedded_energy[i] = spline(self.rho, self.embedded_data[i], k=3) self.electron_density[i] = spline(self.r, self.density_data[i], k=3) self.d_embedded_energy[i] = self.deriv(self.embedded_energy[i]) self.d_electron_density[i] = self.deriv(self.electron_density[i]) self.phi = np.empty([self.Nelements, self.Nelements], object) self.d_phi = np.empty([self.Nelements, self.Nelements], object) # ignore the first point of the phi data because it is forced # to go through zero due to the r*phi format in alloy and adp for i in range(self.Nelements): for j in range(i, self.Nelements): self.phi[i, j] = spline( self.r[1:], self.rphi_data[i, j][1:] / self.r[1:], k=3) self.d_phi[i, j] = self.deriv(self.phi[i, j]) if j != i: self.phi[j, i] = self.phi[i, j] self.d_phi[j, i] = self.d_phi[i, j]
def _lower_ngtm(self, M, mass_function, cut): ### WE CALCULATE THE MASS FUNCTION BELOW THE COMPUTED RANGE ### # mass_function is logged already (not log10 though) m_lower = np.linspace(np.log(10 ** 3), np.log(M[0]), 500) if cut: #since its been cut, the best we can do is a power law mf_func = spline(np.log(M), mass_function, k=1) mf = mf_func(m_lower) else: #We try to calculate the hmf as far as we can normally sigma_0 = tools.mass_variance(np.exp(m_lower), self._power_0, self.lnkh, self.cosmo_params['mean_dens']) sigma = sigma_0 * self.growth dlnsdlnm = tools.dlnsdlnm(np.exp(m_lower), sigma_0, self._power_0, self.lnkh, self.cosmo_params['mean_dens']) n_eff = tools.n_eff(dlnsdlnm) fsigma = fits(m_lower, n_eff, self.mf_fit, sigma, self.cosmo_params['delta_c'], self.z, self.delta_halo, self.cosmo_params, self.user_fit, cut_fit=True).nufnu()() #fsigma = nufnu() dndm = fsigma * self.cosmo_params['mean_dens'] * np.abs(dlnsdlnm) / np.exp(m_lower) ** 2 mf = np.log(np.exp(m_lower) * dndm) if np.isnan(mf[0]): #Then we couldn't go down all the way, so have to do linear ext. mfslice = mf[np.logical_not(np.isnan(mf))] m_nan = m_lower[np.isnan(mf)] m_true = m_lower[np.logical_not(np.isnan(mf))] mf_func = spline(m_true, mfslice, k=1) mf[:len(mfslice)] = mf_func(m_nan) return m_lower, mf
def __init__(self, **model_parameters): super(Tinker08, self).__init__(**model_parameters) if self.delta_halo not in self.delta_virs: A_array = np.array([self.params["A_%s" % d] for d in self.delta_virs]) a_array = np.array([self.params["a_%s" % d] for d in self.delta_virs]) b_array = np.array([self.params["b_%s" % d] for d in self.delta_virs]) c_array = np.array([self.params["c_%s" % d] for d in self.delta_virs]) A_func = spline(self.delta_virs, A_array) a_func = spline(self.delta_virs, a_array) b_func = spline(self.delta_virs, b_array) c_func = spline(self.delta_virs, c_array) A_0 = A_func(self.delta_halo) a_0 = a_func(self.delta_halo) b_0 = b_func(self.delta_halo) c_0 = c_func(self.delta_halo) else: A_0 = self.params["A_%s" % (int(self.delta_halo))] a_0 = self.params["a_%s" % (int(self.delta_halo))] b_0 = self.params["b_%s" % (int(self.delta_halo))] c_0 = self.params["c_%s" % (int(self.delta_halo))] self.A = A_0 * (1 + self.z) ** (-self.params["A_exp"]) self.a = a_0 * (1 + self.z) ** (-self.params["a_exp"]) alpha = 10 ** (-(0.75 / np.log10(self.delta_halo / 75)) ** 1.2) self.b = b_0 * (1 + self.z) ** (-alpha) self.c = c_0
def semi_supervised_test2(df, labeled_points, step): # for i in range(6): total_points = 600 feature, label = seperate_feature_label(df) accuracy_for_supervise = [] accuracy_for_semi_supervise = [] x = [] indices = np.arange(len(feature)) label_indices = balanced_sample_maker(feature, label, labeled_points / len(label)) unlabeled_indices = np.delete(indices, np.array(label_indices)) # print(unlabeled_indices.size) # print(unlabeled_indices.size) rng = np.random.RandomState(0) rng.shuffle(unlabeled_indices) indices = np.concatenate((label_indices, unlabeled_indices[:total_points])) # n_total_samples = len(indices) for i in range(80): x.append(total_points) unlabeled_index = np.arange(total_points)[labeled_points:] # print(unlabeled_index.size) X = feature.iloc[indices] y = label.iloc[indices] y_train = np.copy(y) y_train[unlabeled_index] = -1 # supervised learning classifier = KNeighborsClassifier(n_neighbors=6) classifier.fit(X.iloc[:labeled_points], y.iloc[:labeled_points]) y_pred = classifier.predict(X.iloc[labeled_points:]) true_labels = y.iloc[unlabeled_index] # print(confusion_matrix(true_labels,y_pred)) print("%d labeled & %d unlabeled (%d total)" % (labeled_points, total_points - labeled_points, total_points)) accuracy_for_supervise.append(accuracy_score(true_labels, y_pred)) lp_model = label_propagation.LabelSpreading(gamma=1, kernel='knn', max_iter=300, n_neighbors=6) lp_model.fit(X, y_train) predicted_labels = lp_model.transduction_[unlabeled_index] # print('Iteration %i %s' % (i, 70 * '_')) accuracy_for_semi_supervise.append(accuracy_score(true_labels, predicted_labels)) print('Semi-supervised learning:', accuracy_score(true_labels, predicted_labels)) total_points += step # print(unlabeled_indices[(total_points-50):total_points]) indices = np.concatenate((indices, unlabeled_indices[(total_points - step):total_points])) x_sm = np.array(x) y_sm = np.array(accuracy_for_supervise) y1_sm = np.array(accuracy_for_semi_supervise) x_smooth = np.linspace(x_sm.min(), x_sm.max(), 200) y_smooth = spline(x, y_sm, x_smooth) y1_smooth = spline(x, y1_sm, x_smooth) sup, = plt.plot(x_smooth, y_smooth, label='Supervised learning with kNN') semi_l, = plt.plot(x_smooth, y1_smooth, label='Semi-supervised learning using Label Propagation') # plt.legend(handles=[sup, semi_l]) plt.xlabel('Total samples') plt.ylabel('Accuracy') plt.title('Semi-supervised learning for labeled ' + str(labeled_points) + ' samples ') plt.show() return accuracy_score(true_labels, predicted_labels)
def __init__(self, symbol): """Atomic Setup (Pseudopotential data) data read from data/*_pp.dat files. TODO: expand documentation & cleanup """ self.lref = 1 fname = 'data/' + symbol.lower() + '_pp.dat' datafile = pkg_resources.resource_stream(__name__, fname) self.symbol = symbol self.fname = fname # python doesn't like 1D-2 formating (convert to 1E-2) t = maketrans('D', 'E') data = [l.translate(t).split() for l in datafile] line=0 self.n = int(data[line][0]) self.dx = float(data[line][1]) self.lmax = int(data[line][2]) self.q = float(data[line][3]) line=1 self.rl = np.array([float(r) for r in data[line]]) self.radius = max(self.rl) m = self.n + 3 v = np.array([[float(x) for x in line] for line in data[2:m]]).T u = np.array([[float(x) for x in line] for line in data[m::]]).T x = np.arange(self.n+1) * self.dx # create splines self.v_spline = {l:spline(x, v[l+1], s=0) for l in xrange(self.lmax+1)} self.u_spline = {l:spline(x, u[l+1], s=0) for l in xrange(self.lmax+1)} self.vnl_spline = {} self.psi_spline = {} psi = np.zeros_like(x) vnl = np.zeros_like(x) for l in xrange(self.lmax+1): psi[1::] = u[l+1,1::]/(x[1::]**(l+1)*np.sqrt((2*l+1)/(4*np.pi))) vnl[1::] = (v[l+1,1::]-v[self.lref+1, 1::])*psi[1::] psi[0] = psi[1] vnl[0] = vnl[1] self.psi_spline[l] = spline(x,psi,s=0) self.vnl_spline[l] = spline(x,vnl,s=0) self.L = [l for l in xrange(self.lmax+1) if l != self.lref] self.LM = list(itertools.chain.from_iterable( range(l**2, (l+1)**2) for l in self.L)) self.uVu = self.calculate_uVu()
def _p(self, K, c): """ The reduced dimensionless fourier-transform of the profile This function should not need to be called by the user in general. Parameters ---------- K : float or array_like The unit-less wavenumber k*r_s c : float or array_like The concentration .. note :: This should be replaced by an analytic function if possible """ c = np.atleast_1d(c) if K.ndim < 2: if len(K)!=len(c): K = np.atleast_2d(K).T # should be len(rs) x len(k) else: K = np.atleast_2d(K) minsteps = 100 # if len(c)>50: # C = np.linspace(c.min(),c.max(),50) # else: # C = c # if K.size > 100: kk = np.logspace(np.log10(K.min()),np.log10(K.max()),100) else: kk = np.sort(np.flatten(K)) res = np.zeros_like(K) intermediate_res = np.zeros((len(kk),len(c))) for ik, kappa in enumerate(kk): smallest_period = np.pi / kappa dx = smallest_period / 5 nsteps = max(int(np.ceil(c.max() / dx)),minsteps) x, dx = np.linspace(0, c.max(), nsteps, retstep=True) spl = spline(x, x*self._f(x)*np.sin(kappa*x)/kappa) intg = spl.antiderivative() intermediate_res[ik,:] = intg(c) - intg(0) for ic, cc in enumerate(c): #print intermediate_res.shape, kk.shape, res.shape # For high K, intermediate_res can be negative, so we mask that. mask = intermediate_res[:,ic]>0 spl = spline(np.log(kk[mask]),np.log(intermediate_res[mask,ic]),k=1) res[:,ic] = np.exp(spl(np.log(K[:,ic]))) return res
def HighPassFilter(data, vel, width=5, linearize=False): """ Function to apply a high-pass filter to data. Data must be in an xypoint container, and have linear wavelength spacing vel is the width of the features you want to remove, in velocity space (in cm/s) width is how long it takes the filter to cut off, in units of wavenumber """ if linearize: original_data = data.copy() datafcn = spline(data.x, data.y, k=3) errorfcn = spline(data.x, data.err, k=3) contfcn = spline(data.x, data.cont, k=3) linear = DataStructures.xypoint(data.x.size) linear.x = np.linspace(data.x[0], data.x[-1], linear.size()) linear.y = datafcn(linear.x) linear.err = errorfcn(linear.x) linear.cont = contfcn(linear.x) data = linear # Figure out cutoff frequency from the velocity. featuresize = 2 * data.x.mean() * vel / constants.c.cgs.value # vel MUST be given in units of cm dlam = data.x[1] - data.x[0] # data.x MUST have constant x-spacing Npix = featuresize / dlam nsamples = data.size() sample_rate = 1.0 / dlam nyq_rate = sample_rate / 2.0 # The Nyquist rate of the signal. width /= nyq_rate cutoff_hz = min(1.0 / featuresize, nyq_rate - width * nyq_rate / 2.0) # Cutoff frequency of the filter # The desired attenuation in the stop band, in dB. ripple_db = 60.0 # Compute the order and Kaiser parameter for the FIR filter. N, beta = kaiserord(ripple_db, width) if N % 2 == 0: N += 1 # Use firwin with a Kaiser window to create a lowpass FIR filter. taps = firwin(N, cutoff_hz / nyq_rate, window=('kaiser', beta), pass_zero=False) # Extend data to prevent edge effects y = np.r_[data.y[::-1], data.y, data.y[::-1]] # Use lfilter to filter data with the FIR filter. smoothed_y = lfilter(taps, 1.0, y) # The phase delay of the filtered signal. delay = 0.5 * (N - 1) / sample_rate delay_idx = np.searchsorted(data.x, data.x[0] + delay) smoothed_y = smoothed_y[data.size() + delay_idx:-data.size() + delay_idx] if linearize: fcn = spline(data.x, smoothed_y) return fcn(original_data.x) else: return smoothed_y
def projected_corr_gal(self): """ Projected correlation function w(r_p). From Beutler 2011, eq 6. To integrate perform a substitution y = x - r_p. """ lnr = np.log(self.r) lnxi = np.log(self.corr_gal) p = np.zeros(len(self.r)) # Calculate correlation to higher scales for better integration if self.proj_limit is None: rlim = max(80.0, 5 * self.rmax) else: rlim = self.proj_limit print "RLIM, RMAX", rlim, self.rmax if rlim > self.rmax: upper_h = deepcopy(self) dr = self.r[1] / self.r[0] upper_h.update(rmin=self.rmax * dr, rmax=rlim, rnum=20) fit = spline(np.concatenate((self.r, upper_h.r)), np.concatenate((self.corr_gal, upper_h.corr_gal)), k=3) # [self.corr_gal > 0] maybe? print "FIT: ", fit(0.1) else: fit = spline(self.r, self.corr_gal, k=3) # [self.corr_gal > 0] maybe? print "fit: ", fit(0.1) f_peak = 0.01 a = 0 for i, rp in enumerate(self.r): if a != 1.3 and i < len(self.r) - 1: # Get slope at rp (== index of power law at rp) ydiff = (lnxi[i + 1] - lnxi[i]) / (lnr[i + 1] - lnr[i]) # if the slope is flatter than 1.3, it will converge faster, but to make sure, we cut at 1.3 a = max(1.3, -ydiff) theta = self._get_theta(a) min_y = theta * f_peak ** 2 * rp # Get the upper limit for this rp lim = np.log10(rlim - rp) # Set the y vector for this rp y = np.logspace(np.log10(min_y), lim, 1000) # Integrate integ_corr = fit(y + rp) integrand = integ_corr / np.sqrt((y + 2 * rp) * y) p[i] = intg.simps(integrand, y) * 2 return p
def __init__(self, x, y, xref, yref,weights=None, kx=None,ky=None): if weights==None: weights = np.ones(x.shape) if kx == None: kx = np.linspace(x.min(), x.max()) if ky == None: ky = np.linspace(y.min(), y.max()) self.spline_x = spline(x,y,xref, tx=kx,ty=ky,w=weights) self.spline_y = spline(x,y,yref, tx=kx,ty=ky,w=weights)
def semi_supervised_test1(df, labeled_points, total_points): #split the data according to the classes, generate labelled , unlabelled mark for each and reshuffle. feature, label = seperate_feature_label(df) accuracy_for_supervise =[] accuracy_for_semi_supervise =[] x = [] indices = np.arange(len(feature)) label_indices = balanced_sample_maker(feature, label, labeled_points/len(label)) unlabeled_indices = np.delete(indices, np.array(label_indices)) rng = np.random.RandomState(0) rng.shuffle(unlabeled_indices) indices = np.concatenate((label_indices, unlabeled_indices[:total_points])) n_total_samples = len(indices) for i in range(100): unlabeled_indices=np.arange(n_total_samples)[labeled_points:] X = feature.iloc[indices] y = label.iloc[indices] y_train = np.copy(y) y_train[unlabeled_indices] = -1 classifier = KNeighborsClassifier(n_neighbors=6) classifier.fit(X.iloc[:labeled_points], y.iloc[:labeled_points]) y_pred = classifier.predict(X.iloc[labeled_points:]) # y_all = pd.concat(y.iloc[:labeled_points], y_pred) true_labels = y.iloc[unlabeled_indices] # print(confusion_matrix(true_labels,y_pred)) # print("%d labeled & %d unlabeled (%d total)" # % (labeled_points, n_total_samples - labeled_points, n_total_samples)) accuracy_for_supervise.append(accuracy_score(true_labels, y_pred)) lp_model = label_propagation.LabelSpreading(gamma=0.25, kernel='knn', max_iter=300, n_neighbors=6) lp_model.fit(X, y_train) predicted_labels = lp_model.transduction_[unlabeled_indices] # print('Iteration %i %s' % (i, 70 * '_')) accuracy_for_semi_supervise.append(accuracy_score(true_labels, predicted_labels)) x.append(labeled_points) # print(confusion_matrix(true_labels, predicted_labels)) print('Semi-supervised learning:', accuracy_score(true_labels, predicted_labels)) labeled_points += 5 x_sm = np.array(x) y_sm = np.array(accuracy_for_supervise) y1_sm = np.array(accuracy_for_semi_supervise) x_smooth = np.linspace(x_sm.min(), x_sm.max(), 200) y_smooth = spline(x, y_sm, x_smooth) y1_smooth = spline(x, y1_sm, x_smooth) plt.ylim(0.4, 0.9) sup, = plt.plot(x_sm,y_sm,'b-',label='kNN') semi, = plt.plot(x_sm,y1_sm,'r-',label='Semi-supervised learning') plt.legend(handles=[sup, semi],frameon=False,loc=4,fontsize=20) plt.xlabel('Labeled points',fontsize=20) plt.ylabel('Accuracy',fontsize=20) plt.xticks(fontsize=15) plt.yticks(fontsize=20) plt.title('Semi-supervised learning with Random Selection',fontsize=20)
def CombineXYpoints(xypts, snr=None, xspacing=None, numpoints=None, interp_order=3): """ Function to combine a list of xypoints into a single xypoint. Useful for combining several orders/chips or for coadding spectra Warning! This function is basically un-tested! ***Optional keywords*** snr: the spectra will be weighted by the signal-to-noise ratio before adding xspacing: the x-spacing in the final array numpoints: the number of points in the final array. If neither numpoints nor xspacing is given, the x-spacing in the final array will be determined by averaging the spacing in each of the xypoints. interp_order: the interpolation order. Default is cubic """ if snr is None or type(snr) != list: snr = [1.0] * len(xypts) # Find the maximum range of the x data: first = np.min([o.x[0] for o in xypts]) last = np.max([o.x[-1] for o in xypts]) avg_spacing = np.mean([(o.x[-1] - o.x[0]) / float(o.size() - 1) for o in xypts]) if xspacing is None and numpoints is None: xspacing = avg_spacing if numpoints is None: if xspacing is None: xspacing = avg_spacing numpoints = (last - first) / xspacing x = np.linspace(first, last, numpoints) full_array = DataStructures.xypoint(x=x, y=np.zeros(x.size), err=np.zeros(x.size)) numvals = np.zeros(x.size, dtype=np.float) # The number of arrays each x point is in normalization = 0.0 for xypt in xypts: #interpolator = ErrorPropagationSpline(xypt.x, xypt.y / xypt.cont, xypt.err / xypt.cont, k=interp_order) interpolator = spline(xypt.x, xypt.y/xypt.cont, k=interp_order) err_interpolator = spline(xypt.x, xypt.err/xypt.cont, k=interp_order) left = np.searchsorted(full_array.x, xypt.x[0]) right = np.searchsorted(full_array.x, xypt.x[-1], side='right') if right < xypt.size(): right += 1 numvals[left:right] += 1.0 val, err = interpolator(full_array.x[left:right]), err_interpolator(full_array.x[left:right]) full_array.y[left:right] += val full_array.err[left:right] += err ** 2 full_array.err = np.sqrt(full_array.err) full_array.y[numvals > 0] /= numvals[numvals > 0] return full_array
def __init__(self, **model_parameters): super(Tinker10, self).__init__(**model_parameters) if self.delta_halo not in self.delta_virs: beta_array = np.array([self.params["beta_%s" % d] for d in self.delta_virs]) gamma_array = np.array([self.params["gamma_%s" % d] for d in self.delta_virs]) phi_array = np.array([self.params["phi_%s" % d] for d in self.delta_virs]) eta_array = np.array([self.params["eta_%s" % d] for d in self.delta_virs]) beta_func = spline(self.delta_virs, beta_array) gamma_func = spline(self.delta_virs, gamma_array) phi_func = spline(self.delta_virs, phi_array) eta_func = spline(self.delta_virs, eta_array) beta_0 = beta_func(self.delta_halo) gamma_0 = gamma_func(self.delta_halo) phi_0 = phi_func(self.delta_halo) eta_0 = eta_func(self.delta_halo) else: beta_0 = self.params['beta_%s' % (int(self.delta_halo))] gamma_0 = self.params['gamma_%s' % (int(self.delta_halo))] phi_0 = self.params['phi_%s' % (int(self.delta_halo))] eta_0 = self.params['eta_%s' % (int(self.delta_halo))] self.beta = beta_0 * (1 + min(self.z, self.params["max_z"])) ** self.params["beta_exp"] self.phi = phi_0 * (1 + min(self.z, self.params["max_z"])) ** self.params['phi_exp'] self.eta = eta_0 * (1 + min(self.z, self.params["max_z"])) ** self.params['eta_exp'] self.gamma = gamma_0 * (1 + min(self.z, self.params["max_z"])) ** self.params['gamma_exp'] # # The normalisation only works with specific conditions # gamma > 0 if self.gamma <= 0: if self.terminate: raise ValueError("gamma must be > 0, got " + str(self.gamma)) else: self.gamma = 1e-3 # eta >-0.5 if self.eta <= -0.5: if self.terminate: raise ValueError("eta must be > -0.5, got " + str(self.eta)) else: self.eta = -0.499 # eta-phi >-0.5 if self.eta - self.phi <= -0.5: if self.terminate: raise ValueError("eta-phi must be >-0.5, got " + str(self.eta - self.phi)) else: self.phi = self.eta + 0.499 if self.beta <= 0: if self.terminate: raise ValueError("beta must be > 0, got " + str(self.beta)) else: self.beta = 1e-3
def astropy_smooth(data, vel, linearize=False, kernel=convolution.Gaussian1DKernel, **kern_args): """ Smooth using a gaussian filter, using astropy. Parameters: =========== - data: kglib.utils.DataStructures.xypoint instance The data to smooth. - vel: float The velocity scale to smooth out. Can either by an astropy quantity or a float in km/s - linearize: boolean If True, we will put the data in a constant log-wavelength spacing grid before smoothing. The output has the same spacing as the input regardless of this variable. - kernel: astropy.convolution kernel The astropy kernel to use. The default is the Gaussian1DKernel. - kern_args: Additional kernel arguments beyond width Returns: ======== A smoothed version of the data, on the same wavelength grid as the data """ if linearize: original_data = data.copy() datafcn = spline(data.x, data.y, k=3) linear = DataStructures.xypoint(data.x.size) linear.x = np.logspace(np.log10(data.x[0]), np.log10(data.x[-1]), linear.size()) linear.y = datafcn(linear.x) data = linear # Figure out feature size in pixels if not isinstance(vel, u.quantity.Quantity): vel *= u.km / u.second featuresize = (vel / constants.c).decompose().value dlam = np.log(data.x[1] / data.x[0]) Npix = featuresize / dlam # Make kernel and smooth kern = kernel(Npix, **kern_args) smoothed = convolution.convolve(data.y, kern, boundary='extend') if linearize: fcn = spline(data.x, smoothed) return fcn(original_data.x) return smoothed
def metal_isoch(clust_isoch, clust_isoch_params, zx_pol, zy_pol, m_rang): ''' Selects those isochrone sequences located inside the metallicity range given. ''' # Store in arrays the isoch sequences and params for clusters inside the # metallicty range being processed. clust_isoch_met, clust_isoch_params_met, iso_ages = [], [], [] for indx,iso_param in enumerate(clust_isoch_params): if m_rang[0] <= iso_param[3] <= m_rang[1]: iso_ages.append(iso_param[2]) clust_isoch_met.append(clust_isoch[indx]) clust_isoch_params_met.append(iso_param) # Check for duplicated ages. # Interpolate a single isochrone from those with the same age. # Replace all the isochrones of same age with the newly interpolated one. # Interpolate points close to the final ZAMS so as to smooth the section # were they intersect. clust_isoch_met_z = [] for isoch in clust_isoch_met: # Iterate though ZAMS points ordered in increasing order in y. x3, y3 = [], [] for indx,y1_i in enumerate(zy_pol): if 0. <(y1_i-isoch[1][-1])<=0.4 and zx_pol[indx] > isoch[0][-1]: y3 = [y1_i] x3 = [zx_pol[indx]] break sx = np.array(list(isoch[0])+x3) sy = np.array(list(isoch[1])+y3) t = np.arange(sx.size,dtype=float) t /= t[-1] N = np.linspace(0,1,1000) SX = spline(t,sx,N,order=2) SY = spline(t,sy,N,order=2) # Append interpolated isochrone. clust_isoch_met_z.append([SX.tolist(), SY.tolist()]) # Sort all lists according to age. if iso_ages: iso_ages_s, clust_isoch_met_s, clust_isoch_params_met_s = \ map(list, zip(*sorted(zip(iso_ages, clust_isoch_met_z, clust_isoch_params_met), reverse=True))) else: iso_ages_s, clust_isoch_met_s, clust_isoch_params_met_s = [], [], [] return iso_ages_s, clust_isoch_met_s, clust_isoch_params_met_s
def semi_supervised_test2(df ,labeled_points, step): total_points = labeled_points+50 feature ,label = seperate_feature_label(df) accuracy_for_supervise=[] accuracy_for_semi_supervise=[] x=[] indices = np.arange(len(feature)) label_indices = balanced_sample_maker(feature,label,labeled_points/len(label)) unlabeled_indices=np.delete(indices,np.array(label_indices)) rng = np.random.RandomState(0) rng.shuffle(unlabeled_indices) indices = np.concatenate((label_indices,unlabeled_indices[:total_points])) # (len(df.index)-labeled_points-50) # print(len((df.index))) for i in range(int(len((df.index)-labeled_points-50)/step)): x.append(total_points) unlabeled_index = np.arange(total_points)[labeled_points:] X = feature.iloc[indices] y = label.iloc[indices] print(len(y.index)) print(unlabeled_index) y_train = np.copy(y) y_train[unlabeled_index] = -1 classifier = KNeighborsClassifier(n_neighbors=6) classifier.fit(X.iloc[:labeled_points],y.iloc[:labeled_points]) y_pred = classifier.predict(X.iloc[labeled_points:]) true_labels = y.iloc[unlabeled_index] accuracy_for_supervise.append(accuracy_score(true_labels,y_pred)) lp_model = label_propagation.LabelSpreading(gamma=0.25, kernel='knn',max_iter=300, n_neighbors=6) lp_model.fit(X, y_train) predicted_labels = lp_model.transduction_[unlabeled_index] accuracy_for_semi_supervise.append(accuracy_score(true_labels, predicted_labels)) total_points += step indices = np.concatenate((indices,unlabeled_indices[(total_points-step):total_points])) # print('accuracy gain average with %d labels:%d'%(labeled_points, np.average(accuracy_for_semi_supervise)-np.average(accuracy_for_semi_supervise))) x_sm = np.array(x) # print(x_sm) y_sm = np.array(accuracy_for_supervise) # print(y_sm) y1_sm=np.array(accuracy_for_semi_supervise) x_smooth = np.linspace(x_sm.min(), x_sm.max(), 200) y_smooth = spline(x, y_sm, x_smooth) y1_smooth = spline(x, y1_sm, x_smooth) sup, = plt.plot(x_sm,y_smooth,'b-',label='kNN') semi, = plt.plot(x_sm,y1_smooth,'r-',label='Label Propagation') plt.legend(handles=[sup, semi],frameon=False,loc=4) plt.ylim(0.4, 1) plt.xlabel('Total samples',fontsize=20) plt.xticks(fontsize=15) plt.yticks(fontsize=20) plt.ylabel('Accuracy',fontsize=20) plt.title('Learning curve with '+str(labeled_points)+'labels',fontsize=20) return accuracy_score(true_labels, predicted_labels)
def makeSimpleGraph(): baseFile = open('betterFile3.txt',mode = 'r') lines = [] for line in baseFile: group = line.split() lines.append(group) lines = [line for line in lines if len(line)==8] gen = str(20) platinumPairs = [((line[0]=='Pt')*int(line[2])+(line[1]=='Pt')*(85-int(line[2])),int(line[7])) for line in lines if line[6]==gen] silverPairs = [((line[0]=='Ag')*int(line[2])+(line[1]=='Ag')*(85-int(line[2])),int(line[7])) for line in lines if line[6]==gen] nickelPairs = [((line[0]=='Ni')*int(line[2])+(line[1]=='Ni')*(85-int(line[2])),int(line[7])) for line in lines if line[6]==gen] copperPairs = [((line[0]=='Cu')*int(line[2])+(line[1]=='Cu')*(85-int(line[2])),int(line[7])) for line in lines if line[6]==gen] platY = [] silverY = [] nickelY = [] copperY = [] for k in range(LENGTH): platY.append(sum( piece[0] for piece in platinumPairs if piece[1]==k )/78.75 ) silverY.append(sum( piece[0] for piece in silverPairs if piece[1]==k )/78.75 ) nickelY.append(sum( piece[0] for piece in nickelPairs if piece[1]==k )/78.75 ) copperY.append(sum( piece[0] for piece in copperPairs if piece[1]==k )/78.75 ) xRange = range(LENGTH) xNew = np.linspace(min(xRange),max(xRange),20) power_smooth1 = spline(xRange,platY,xNew) power_smooth2 = spline(xRange,silverY,xNew) power_smooth3 = spline(xRange,nickelY,xNew) power_smooth4 = spline(xRange,copperY,xNew) plt.title("% Composition per Alpha Value") #plt.plot(xRange,platY,color='b',label = "Pt") #plt.plot(xRange,silverY,color='r',label= "Ag") #plt.plot(xRange,nickelY,color='g',label="Ni") #plt.plot(xRange,copperY,color='y',label="Cu") plt.plot(xNew,power_smooth1,color='b',label="Pt") plt.plot(xNew,power_smooth2,color='r',label="Ag") plt.plot(xNew,power_smooth3,color='g',label="Ni") plt.plot(xNew,power_smooth4,color='y',label="Cu") plt.xlabel("Alpha Value") plt.ylabel("Percent Composition") plt.legend(loc="center left",bbox_to_anchor=(1,0.5)) plt.show()
def nbar(self, val): """ Set the number density as a function of redshift, :math:`n(z)` This should be either: 1. a string, specifying the name of the file to read :math:`n(z)` from; the file should contain two columns, specifying ``(z, nz)`` 2. a float, specifying the constant :math:`n(z)` value to use """ if val is not None: # input is an existing file if isinstance(val, six.string_types) and os.path.exists(val): # read from the file try: d = numpy.loadtxt(val) # columns are z, n(z) if d.shape[1] == 2: self._nbar = spline(d[:,0], d[:,1]) # columns are z_min, z_max, z_cen, n(z) elif d.shape[1] == 4: self._nbar = spline(d[:,-2], d[:,-1]) # wrong number of columns else: raise except: raise ValueError("n(z) file should specify either: [z, n(z)] or [z_min, z_max, z_cen, n(z)]") # redshift is required for the n(z) spline self._nbar.need_redshift = True # input is a float, specifying the constant nbar elif isinstance(val, six.string_types) and is_float(val) or numpy.isscalar(val): val = float(val) def constant_nbar(redshift): nbar = numpy.array(val) nbar = numpy.lib.stride_tricks.as_strided(nbar, (len(redshift), nbar.size), (0, nbar.itemsize)) return nbar.squeeze() self._nbar = constant_nbar # return a constant n(z) self._nbar.need_redshift = False else: msg = ("error setting ``nbar`` parameter from input value; should " " be either the name of a file, or a float value if n(z) is constant") raise TypeError(msg) else: self._nbar = None
def plot_fig(x_label, y_label): new1_x = np.linspace(min(plot1_x), max(plot1_x), 1000) new1_y = spline(plot1_x, plot1_y, new1_x) new2_x = np.linspace(min(plot2_x), max(plot2_x), 1000) new2_y = spline(plot2_x, plot2_y, new2_x) plt.plot(new1_x, new1_y, 'b', label='Test Accuracy') plt.plot(new2_x, new2_y, 'g', label='Train Accuracy') # plt.plot(plot1_x, plot1_y, 'b', label='Test Accuracy') # plt.plot(plot2_x, plot2_y, 'g', label='Train Accuracy') plt.legend(loc=0) plt.xlabel(x_label) plt.ylabel(y_label) plt.show()
def IterativeLowPass(data, vel, numiter=100, lowreject=3, highreject=3, width=5, linearize=False): """ An iterative version of LowPassFilter. It will ignore outliers in the low pass filter. New parameters that are not described in the docstring fro LowPassFilter are: Parameters: =========== - numiter: integer The maximum number of iterations to take - lowreject: integer How many sigma below the current filtered curve do we count as bad and ignore in the next iteration? - highreject: integer How many sigma above the current filtered curve do we count as bad and ignore in the next iteration? """ datacopy = data.copy() if linearize: datafcn = spline(datacopy.x, datacopy.y, k=3) errorfcn = spline(datacopy.x, datacopy.err, k=1) contfcn = spline(datacopy.x, datacopy.cont, k=1) linear = DataStructures.xypoint(datacopy.x.size) linear.x = np.linspace(datacopy.x[0], datacopy.x[-1], linear.size()) linear.y = datafcn(linear.x) linear.err = errorfcn(linear.x) linear.cont = contfcn(linear.x) datacopy = linear.copy() done = False iter = 0 datacopy.cont = FittingUtilities.Continuum(datacopy.x, datacopy.y, fitorder=9, lowreject=2.5, highreject=5) while not done and iter < numiter: done = True iter += 1 smoothed = LowPassFilter(datacopy, vel, width=width) residuals = datacopy.y / smoothed mean = np.mean(residuals) std = np.std(residuals) badpoints = np.where(np.logical_or((residuals - mean) < -lowreject * std, residuals - mean > highreject * std))[ 0] if badpoints.size > 0: done = False datacopy.y[badpoints] = smoothed[badpoints] if linearize: return linear.x, smoothed else: return smoothed
def betamax(_gwylmo,n=10,plt=False,opt=True,verbose=False): from scipy.interpolate import interp1d as spline from scipy.optimize import minimize from numpy import pi,linspace,argmax,array dphi_list = pi*linspace(-1,1,n) dpsi,val = [],[] for dphi in dphi_list: [dpsi_,val_] = alphamax(_gwylmo,dphi,plt=False,n=n) dpsi.append( dpsi_ ) val.append( val_ ) dphis = linspace(min(dphi_list),max(dphi_list),1e3) vals = spline( dphi_list, val, kind='cubic' )( dphis ) dpsi_s = spline( dphi_list, dpsi, kind='cubic' )( dphis ) action = lambda x: -sum( vectorize( _gwylmo, x[0], x[1] ) ) dphi_opt_guess = dphis[argmax(vals)] dpsi_opt_guess = dpsi_s[argmax(vals)] if opt: K = minimize( action, [dphi_opt_guess,dpsi_opt_guess] ) # print K dphi_opt,dpsi_opt = K.x val_max = -K.fun else: dphi_opt = dphi_opt_guess dpsi_opt = dpsi_opt_guess val_max = vals.max() if plt: # Setup plotting backend import matplotlib as mpl from mpl_toolkits.mplot3d import axes3d mpl.rcParams['lines.linewidth'] = 0.8 mpl.rcParams['font.family'] = 'serif' mpl.rcParams['font.size'] = 12 mpl.rcParams['axes.labelsize'] = 20 mpl.rcParams['axes.titlesize'] = 20 from matplotlib.pyplot import plot,xlabel,title plot( dphi_list, val, linewidth=4, alpha=0.1, color='k' ) plot( dphi_opt, val_max, 'or', alpha=0.5 ) plot( dphis, vals ) xlabel(r'$\phi$') title(val_max) if verbose: print 'dphi_opt = ' + str(dphi_opt) print 'dpsi_opt = ' + str(dpsi_opt) print 'val_max = ' + str(val_max) return dphi_opt,dpsi_opt
def makeReferenceRLHistogram(alnRatios, refLengths, outfile, format, quantile): """ X-axis: (unique) reference length Y-axis: count """ fig = plt.figure(dpi=300, figsize=(10, 6)) ax = fig.add_subplot(111) ax.set_title("Aligned Reference Length Distribution (qCov>=80%)") fullPass = alnRatios[alnRatios['IsFullPass']&(alnRatios['rCov']>=.8)] fullLength = alnRatios[alnRatios['IsFullLength']&(alnRatios['rCov']>=.8)] if quantile is not None: refLengths = refLengths[refLengths < mstats.mquantiles(refLengths, [quantile])[0]] # plot all references first bins = 50 y,binEdges = n.histogram(refLengths, bins=bins) bincenters = 0.5*(binEdges[1:]+binEdges[:-1]) xnew = n.linspace(bincenters.min(), bincenters.max(), 100) ysmooth = spline(bincenters, y, xnew) # normalize by hand ysmooth = ysmooth*1./sum(ysmooth) ax.plot(xnew, ysmooth, '-', label="All References") max_y = max(ysmooth) for l, label in zip((fullPass, fullLength), ("Aligned full-pass subreads", "Aligned " + SeenName + " subreads")): alnRefLength = dict(zip(l['RefID'], l['RefLength'])) if len(alnRefLength) == 0: continue alnRefLength = n.array(alnRefLength.values()) if quantile is not None: alnRefLength = alnRefLength[alnRefLength < mstats.mquantiles(alnRefLength, [quantile])[0]] bins = (max(alnRefLength)-min(alnRefLength))/100 + 1 y,binEdges = n.histogram(alnRefLength, bins=bins) bincenters = 0.5*(binEdges[1:]+binEdges[:-1]) xnew = n.linspace(bincenters.min(), bincenters.max(), 300) ysmooth = spline(bincenters, y, xnew) # normalize by hand ysmooth = ysmooth*1./sum(ysmooth) ax.plot(xnew, ysmooth, '-', label=label) max_y = max(max_y, max(ysmooth)) #num, bins, patches = ax.hist(alnRefLength, bins=50, histtype='step', label=label, normed=True) #max_y = max(max_y, max(num)) ax.set_ylim(0, max_y * 1.1) ax.legend(loc='upper center', prop={'size': 'small'}) ax.set_xlabel("Reference Length") ax.set_ylabel("Fraction") fig.savefig(outfile, format=format)
def xCoordinates(sobel_img): num_rows = float(len(sobel_img)) # get number of x values # sum along y axis vert_sum = np.sum(sobel_img,axis=0) # make it an average value (divide by # of x values) vert_sum = np.divide(vert_sum,num_rows) x = np.arange(0,len(vert_sum)) # for graphing xnew = np.arange(0,len(vert_sum),50) # for smoothing #smooth y_smooth = spline(x, vert_sum, xnew) #make a sin curve 1/3 of the width of image img_width, img_height = sobel_img.shape z = np.arange(0,int(img_width/3),1) def f(x): return np.sin(x/90)*-15 + 25 f = [f(i) for i in z] # make sine into an array # convolve sine and the vertical sum y_conv = np.convolve(vert_sum, f,'same') # detect local minima mins = (np.diff(np.sign(np.diff(y_conv))) > 0).nonzero()[0] + 1 return mins
def yCoordinates(sobel_img): num_col = float(len(sobel_img[0])) #number of y values # sum along x axis horiz_sum = np.sum(sobel_img, axis=1) #average value horiz_sum = np.divide(horiz_sum, num_col) y = np.arange(0, len(horiz_sum)) ynew = np.arange(0, len(horiz_sum)) x_smooth = spline(y, horiz_sum, ynew) #make a sin curve 1/3 of the height img_width, img_height = sobel_img.shape z = np.arange(0,int(img_height/3),1) def f(x): return np.sin(x/90)*-15 + 25 f = [f(i) for i in z] # make sine into an array # convolve sine and the vertical sum y_conv = np.convolve(horiz_sum, f,'same') # detect local minima mins = (np.diff(np.sign(np.diff(y_conv))) > 0).nonzero()[0] + 1 return mins
def simula4(): #parametros numero_ciclos= 1 tempo_simulacao = 1000000 u=[]#lista para plotar valor=[]#lista para plotar ##TODO: melhores nomes para as variáveis for w in range(1,20): u_servidor = round(0.5*(w+1), 2)#lambda do problema media=0 for q in range(numero_ciclos): fila = 0 i = 0 j = 0 servidor = 0 tempo_proximo = 0 entrada = 0 ##tempo até a próxima entrada tempo_proximo = 0 ##tempo até terminar a execução no servidor ##variáveis para calcular a média tempo = 0 esperanca = 0 fim = 0 while (1): if(tempo == tempo_simulacao): esperanca = esperanca / tempo #print('a número médio de pessoas no sistema é: ' + str(esperanca)) media= media + esperanca/numero_ciclos break ##if(i == numero_de_aleatorios and j == numero_de_aleatorios): ## esperanca = esperanca / tempo ## #print('a número médio de pessoas no sistema é: ' + str(esperanca)) ## media= media + esperanca/numero_ciclos ## break while(entrada == 0): uniforme = np.random.uniform(5,15) entrada = int(uniforme) ##Gera uma nova entrada exponencial resto += uniforme - entrada if(resto > 1): entrada += 1 fila+= 1 i += 1 entrada -= 1 ## while nescessário caso caia em um tempo = 0 novamente resto = 0 while(tempo_proximo == 0 and fila > 0): servidor = 1 fila -= 1 aleatorio = np.random.random_sample() if(aleatorio > 0.9): fila +=1 exponencial = np.random.exponential(1/u_servidor) tempo_proximo = int(exponencial) resto += exponencial - tempo_proximo if(resto > 1): tempo_proximo += 1 j += 1 if(fila == 0 and tempo_proximo == 0): servidor = 0 else: tempo_proximo -= 1 ##coisas inuteis para parar quando já tudo processado ##nunca será executável pois para depois da ultima remessa da entrada if(fim == 0): ##print('fila = ' + str(fila)) ##print('servidor = ' + str(servidor)) pass else: break if(tempo == tempo_simulacao): fim = 1 esperanca += fila + servidor ##soma o número de clientes no sistema tempo += 1 ##adiciona mais um no tempo ##executando a função main print("Media das medias: ", media) u.append(u_servidor) valor.append(media) plt.figure(figsize=(8, 6), dpi=100) x_smooth = np.linspace(min(u), max(u), 10000) y_smooth = spline (u, valor, x_smooth) plt.plot(x_smooth,y_smooth,'-b', label="Curva Amortizada") plt.plot(u, valor, 'bo', label="Pontos Da Curva") #plt.plot(lamb, valor2, '-ro', label="Curva Teste") plt.axis([0, 1.1*(max(u)), 0, 1.2*(max(valor))]) plt.suptitle('Cenário-3', fontsize=20) plt.xlabel('Lambda', fontsize=15) plt.ylabel('Média', fontsize=15) plt.legend(loc=1, prop={'size':10}) plt.show()
ax = plt.subplot(111,zorder=8) ax.plot(rVector[:-4]/TOF, density[:-4]/scale, 'ko',markersize=5.5,zorder=1,clip_on=False) x_all = rVectorAll/TOF x_pts = rVector/TOF x_to_0 = np.append(0,x_pts) fermi_to_0 = np.append(density_fermi[0],density_fermi) thermal_to_0 = np.append(density_thermal[0],density_thermal) x_plot = np.linspace(min(x_all),max(x_all),1000) y_fermi = spline(x_to_0, fermi_to_0, x_plot) y_thermal = spline(x_to_0, thermal_to_0, x_plot) h2 = plt.plot(x_plot, y_fermi/scale, 'b',label='Fermi-Dirac',linewidth=1.5,zorder=3) h1 = plt.plot(x_plot, y_thermal/scale, 'r',label='Thermal',linewidth=1.5,zorder=2) ax.xaxis.set_ticks_position('bottom') ax.yaxis.set_ticks_position('left') plt.xlabel('Velocity (mm/s)') plt.ylabel('Column density (a.u.)') ax.tick_params(axis='y', which='major', pad=12) legend = plt.legend(frameon=False, fontsize=12,numpoints=1,loc=3) plt.ylim(0,1) plt.xlim(0, V_MAX)
def plot_dynamic_spectra(spectra_wavelengths, spectra, parameters): """ Plot the model spectra vs the observed spectra (interpolated) """ ##### prepare a spectrum array spectra_array = np.zeros([100, len(spectra_wavelengths)]) for phase in spectra.keys(): for spectrum in spectra[phase].keys(): spectra_array[phase, :] = spectra[phase][spectrum] spectra_dict = spectra n_phases = len(spectra_dict.keys()) list_phases = [] for count, ph in enumerate(spectra_dict.keys()): list_phases.append(ph) list_phases.sort() array_phases = 0.01 * np.array(list_phases) n_phases = len(array_phases) spectra_temp = np.zeros((len(spectra_wavelengths), n_phases)) triple_spectra = np.zeros((len(spectra_wavelengths), 3 * n_phases)) triple_phases = np.zeros(3 * n_phases) for i in range(3): triple_phases[i * n_phases:(i + 1) * n_phases] = array_phases + (i - 1) for count, key in enumerate(list_phases): mean_data = np.zeros(len(spectra_wavelengths)) for spectr in spectra_dict[key]: mean_data += spectra_dict[key][spectr] mean_data /= len(spectra_dict[key]) spectra_temp[:, count] = mean_data triple_spectra[:, count] = mean_data triple_spectra[:, count + n_phases] = mean_data triple_spectra[:, count + 2 * n_phases] = mean_data interpolated_data = np.zeros((len(spectra_wavelengths), 100)) phases = np.arange(0, 1.0, 0.01) from scipy.interpolate import interp1d from scipy.interpolate import interp2d from scipy.interpolate import spline import matplotlib.gridspec as gridspec ###### observed spectra ######################################################## colormap = plt.cm.seismic gs1 = gridspec.GridSpec(1, 1) my_dpi = 100 fig = plt.figure(figsize=(1200 / my_dpi, 600 / my_dpi), dpi=my_dpi) axes = fig.add_subplot(gs1[0]) for w, wave in enumerate(spectra_wavelengths): interp_wave = spline(triple_phases, triple_spectra[w, :], phases, order=1, kind='smoothest') interpolated_data[w, :] = interp_wave central_wavelength = parameters['OTHER']['central_wavelength'] axes.imshow(interpolated_data.T, cmap=colormap, \ extent=((spectra_wavelengths[0] - central_wavelength)/\ central_wavelength*3.e5, (spectra_wavelengths[-1] - central_wavelength)/\ central_wavelength*3.e5, 1, 0),\ origin='upper', vmin=0.2, vmax=1.8, aspect='auto') # plt.suptitle("Observations vs model") axes.set_xlabel('RV (km/s)', fontsize=18) axes.set_ylabel('Phase', fontsize=18) plt.show()
file_ = 'output_es_mac300.txt' with open(file_, 'r') as f: for line in f: listt_3.append(line) X1 = list(map(int, listt_3[0].strip().split(' '))) Y1 = list(map(int, listt_3[1].strip().split(' '))) firstDeadNodeRound = findFirstDeadNodeRound(X1, Y1) lastDeadNodeRound = findLastDeadNodeRound(X1, Y1) roundAxis = roundAxis[0:firstDeadNodeRound // 2] + roundAxis[firstDeadNodeRound // 2:6000:100] numberOfDeadNodesAxis = numberOfDeadNodesAxis[ 0:firstDeadNodeRound // 2] + numberOfDeadNodesAxis[firstDeadNodeRound // 2:6000:100] roundAxis = np.asarray(roundAxis) numberOfDeadNodesAxis = np.asarray(numberOfDeadNodesAxis) roundAxis_new = np.linspace(roundAxis.min(), roundAxis.max(), 60000) numberOfDeadNodesAxis_smooth = spline(roundAxis, numberOfDeadNodesAxis, roundAxis_new) plt.text(firstDeadNodeRound - 100, -10, firstDeadNodeRound) plt.text(lastDeadNodeRound - 100, 305, lastDeadNodeRound) plt.plot(roundAxis_new, numberOfDeadNodesAxis_smooth, 'r', label='ES-MAC') plt.xlabel('Number of rounds') plt.ylabel('Number of Dead Nodes') plt.title( 'Graph between number of Dead nodes and number of rounds\n(100x100 grid)') plt.legend() plt.show() if (show_graphics == 1): done()
def plotTrajectories( energy, K_t, koff, outputDir="/Users/jameskomianos/Code/stochfilaments/data-PROD3/data-NM/output/", saveDir="/Users/jameskomianos/Desktop/"): #predicted steady state lo_ss = energy * common.kT * ( 1.0 / (1.0 + (v / v_b) * math.exp(-energy))) / (2.0 * 10.0 * K_t) print "Predicted steady-state overlap = ", lo_ss #mpl.rcParams['axes.color_cycle'] = ['y','k','darkgreen'] #mpl.rcParams['axes.color_cycle'] = ['b', 'g', 'r', 'c'] mpl.rcParams['axes.color_cycle'] = [ 'darkorange', 'darkorange', 'blueviolet', 'blueviolet', 'brown', 'brown', 'darkblue' ] pvals = [] perrs = [] k_minus = koff runtime = 200.0 numIntervals = 200.0 l_intervals = pickle.load( open( outputDir + "/intervalsl-e%0.0f-Kt%0.3f-koff%0.4f.p" % (energy, K_t, k_minus), "rb")) if (len(l_intervals) != 0): intervalTime = runtime / numIntervals t = [] l = [] devs = [] errplus = [] errminus = [] intervalTime = 0 for i in xrange(0, len(l_intervals)): intervalTime += runtime / numIntervals lset = l_intervals[i] lval = np.mean(lset) l.append(lval) t.append(intervalTime) dev = np.std(lset) / math.sqrt(250.0) devs.append(dev) errplus.append(lval + dev) errminus.append(lval - dev) logl = [math.log(x) for x in l if x > 0] logt = [math.log(x) for x in t if x > 0] logdev = [] index = 0 for lval in l: logdev.append(0.434 * devs[index] / lval) index += 1 #truncate for relevance #semi-log is needed for t~tlab index = 0 logl_semil = [] t_semil = [] logl_ll = [] logt_ll = [] flag = "LIN_COLLECT" initSlope = 0.0 tautrans = 0.0 for tval in t: if (flag == "EXP_COLLECT" and tval > tautrans * 2): logl_semil.append(math.log(l[index])) t_semil.append(t[index]) if (flag == "LIN_COLLECT"): logl_ll.append(logl[index]) logt_ll.append(logt[index]) if (len(logl_ll) > 2): slope, intercept, r_value, p_value, std_err = stats.linregress( logt_ll, logl_ll) if (len(logl_ll) == 3): initSlope = slope elif (abs(slope - initSlope) / initSlope >= 0.10): tautrans = tval flag = "EXP_COLLECT" index += 1 lo_last = l[index - 1] print "Transition time = ", tautrans, " s" #plot trajectory plt.figure(8, figsize=(3.5, 2.5)) #smooth out that = np.linspace(min(t), max(t), 10000) lhat = spline(t, l, that) p = plt.plot(that, lhat, markersize=2, linewidth=2.0) color = p[0].get_color() plt.fill_between(t, errplus, errminus, color=color, alpha=0.3) plt.xlabel(r'$\mathsf{Time\/ (s)}$', fontsize=12) plt.ylabel(r'$\mathsf{\langle l_o \rangle\/(nm)}$', fontsize=12) plt.savefig(saveDir + '/traj.pdf', format='pdf') plt.xlim((0, 100)) #plot log(l) vs log(t) plt.figure(10, figsize=(3.5, 3)) plt.errorbar(logt, logl, fmt='o', yerr=logdev) #, mfc='white', zorder=1) plt.xlabel(r'$\mathsf{log(t)}$', fontsize=12) plt.ylabel(r'$\mathsf{log(\langle l_o \rangle)}$', fontsize=12) plt.savefig(saveDir + '/trajlog.pdf', format='pdf') #regression print slope, intercept, r_value, p_value, std_err = stats.linregress( logt_ll, logl_ll) print "Log-log plot..." print "Observed alpha_l = ", math.exp(intercept) print "r^2 = ", r_value * r_value print "std_err = ", std_err print "v = ", slope #plot log(l) vs t plt.figure(9, figsize=(3, 3)) plt.errorbar(t, logl, fmt='o-', yerr=logdev) plt.xlabel(r'$\mathsf{Time\/ (s)}$', fontsize=12) plt.ylabel(r'$\mathsf{log(\langle l_o \rangle)}$', fontsize=12) plt.savefig(saveDir + '/trajsemilog.pdf', format='pdf') slope, intercept, r_value, p_value, std_err = stats.linregress( t_semil, logl_semil) print print "Semi-log plot..." print "Observed alpha = ", math.exp(intercept) print "r^2 = ", r_value * r_value print "std_err = ", std_err print "u = ", slope
""" """ fp = open("GRU.pickle", 'rb') y_gru = np.array(cPickle.load(fp)) fp = open("LSTM.pickle", 'rb') y_lstm = np.array(cPickle.load(fp)) fp = open("BiRNN.pickle", 'rb') y_birnn = np.array(cPickle.load(fp)) x = np.array([i for i in range(len(y_gru))]) x_smooth = np.linspace(x.min(), x.max(), 300) y_gru_smooth = spline(x, y_gru, x_smooth) y_lstm_smooth = spline(x, y_lstm, x_smooth) y_birnn_smooth = spline(x, y_birnn, x_smooth) plt.figure() plt.plot(x_smooth, y_gru_smooth, ':') plt.plot(x_smooth, y_lstm_smooth, '--') plt.plot(x_smooth, y_birnn_smooth, '-') plt.grid(alpha=0.5) plt.legend(['GRU', 'LSTM', 'BiRNN'], loc='upper right') plt.show() fp = open("BiRNN_slot3.pickle", 'rb') y_birnn3 = np.array(cPickle.load(fp)) x = np.array([i for i in range(len(y_birnn3))])
maxLength = len(x) for x in band_energies: for y in range(maxLength - len(x)): x.append(x[-1]) assert (npoint) == len(idx) band_energies = asarray(band_energies) # Now perform spline interpolation on band structure, if requested if should_spline == True: xvals_smooth = np.linspace( xvals.min(), xvals.max(), spline_factor * len(xvals)) # Interpolated x axis for spline smoothing new_band_energies = [] for b in range(band_energies.shape[1] ): # Spline every band, one by one new_band_energies.append( spline(xvals, band_energies[:, b], xvals_smooth)) band_energies = asarray(new_band_energies).transpose( ) # recombine the bands back into the original data format xvals_plot = xvals_smooth # and use the interpolated x axis for plotting else: xvals_plot = xvals # Use the "raw" x axis for plotting for b in range(band_energies.shape[1]): # Make sure legend entry only appears once if b == 0 and iband == 1: if max_spin_channel[i] > 1 and spin == 1: ax_bands.plot(xvals_plot, band_energies[:, b], color=color_array[i], label=plotName[i] + " up") elif max_spin_channel[i] > 1 and spin == 2:
linear_ins_value2 = interp1d(x, y2) print('当x为6,7时,对应的线性插值y1的值为:', linear_ins_value1([6, 7])) print('当x为6,7时,对应的线性插值y2的值为:', linear_ins_value2([6, 7])) # 拉格朗日插值 from scipy.interpolate import lagrange lg_ins_value1 = lagrange(x, y1) lg_ins_value2 = lagrange(x, y2) print('当x为6,7时,对应的拉格朗日插值y1的值为:', lg_ins_value1([6, 7])) print('当x为6,7时,对应的拉格朗日插值y2的值为:', lg_ins_value2([6, 7])) # 样条插值--推荐用BSpline替换 from scipy.interpolate import spline spline_ins_value1 = spline(x, y1, xnew=np.array([6, 7])) spline_ins_value2 = spline(x, y2, xnew=np.array([6, 7])) print('当x为6,7时,对应的样条插值y1的值为:', spline_ins_value1) print('当x为6,7时,对应的样条插值y2的值为:', spline_ins_value2) # 5.2.3检测与处理异常值:3σ原则和箱线图 # ①3σ原则:局限性只能针对正态分布或者近似正态分布的数据有效 def out_range(ser1): bool_ind = (ser1.mean() - 3 * ser1.std() > ser1) | (ser1.mean() + 3 * ser1.var() < ser1) index = np.arange(ser1.shape[0])[bool_ind] outrange = ser1.iloc[index] return outrange
def smooth(Time,Y): f = interpolate.spline(Time, Y,Time) return f(Time)
# data_P = [0, 0, 0, 0, 0, 0, 1, 1, 0, 3, 2, 5, 8, 7, 6, 4, 1, 0, 0, 0] # data_P = [0, 0, 0, 0, 1, 1, 10, 7, 26, 27, 53, 52, 50, 39, 28, 17, 10, 9, 3, 1] # data_P = [0, 0, 0, 0, 0, 4, 6, 15, 31, 20, 42, 43, 44, 50, 40, 15, 14, 3, 3, 4] wsum_P = sum(data_P) data_P[:] = [float(weight) / wsum_P for weight in data_P] wsum_N = sum(data_N) data_N[:] = [float(weight) / wsum_N for weight in data_N] ############################################################################### # Line Plot ############################################################################### # bincenters = 0.5 * (bins[1:] + bins[:-1]) newcenters = np.linspace(min(bincenters), max(bincenters), 300) smooth_P = spline(bincenters, data_P, newcenters) smooth_N = spline(bincenters, data_N, newcenters) plt.plot(newcenters, smooth_P, '-', color='#1f77b4', label="True Matches") plt.plot(newcenters, smooth_N, '-', color='#ff7f0e', label="True Non-Matches") plt.xlabel("Similarity") plt.ylabel("Amount") plt.ylim(0, max(max(smooth_P), max(smooth_N)) + 0.02) plt.title("True Ground Truth Distribution (ncvoter)") plt.legend(loc="best") ############################################################################### # Histogram ############################################################################### # fig = plt.figure(dpi=None, facecolor="white") # ax = fig.add_subplot(111)
# Display data with HDIs of posterior predictions. plt.figure() # Plot data values: y_lim = [np.min(y_HDI_lim), np.max(y_HDI_lim)] plt.plot(x, y, 'k.') plt.xlim(x_lim) plt.ylim(y_lim) plt.xlabel('X (height in inches)') plt.ylabel('Y (weight in pounds)') plt.title('Data with 95% HDI & Mean of Posterior Predictions') # Superimpose posterior predicted 95% HDIs: y_post_pred_ave = np.average(y_post_pred, axis=1) #Book version of the HDI representation #plt.errorbar(x_post_pred,y_post_pred_ave, # yerr=[abs(y_HDI_lim[:,0]-y_post_pred_ave), # abs(y_HDI_lim[:,1]-y_post_pred_ave)], fmt='.') #Smoothed version of the HDI representation x_new = np.linspace(x_post_pred.min(), x_post_pred.max(), 200) y_HDI_lim_smooth = spline(x_post_pred, y_HDI_lim, x_new) plt.plot(x_post_pred, y_post_pred_ave) plt.fill_between(x_new, y_HDI_lim_smooth[:, 0], y_HDI_lim_smooth[:, 1], alpha=0.3) plt.savefig('Figure_16.6.png') plt.show()
roundAxis_1 = list(map(int, listt_1[0].strip().split(' '))) numberOfDeadNodesAxis_1 = list(map(int, listt_1[1].strip().split(' '))) firstDeadNodeRound_1 = findFirstDeadNodeRound(roundAxis_1, numberOfDeadNodesAxis_1) lastDeadNodeRound_1 = findLastDeadNodeRound(roundAxis_1, numberOfDeadNodesAxis_1) roundAxis_1 = roundAxis_1[0:firstDeadNodeRound_1 // 2] + roundAxis_1[firstDeadNodeRound_1 // 2:6000:60] numberOfDeadNodesAxis_1 = numberOfDeadNodesAxis_1[ 0:firstDeadNodeRound_1 // 2] + numberOfDeadNodesAxis_1[firstDeadNodeRound_1 // 2:6000:60] roundAxis_1 = np.asarray(roundAxis_1) numberOfDeadNodesAxis_1 = np.asarray(numberOfDeadNodesAxis_1) roundAxis_new_1 = np.linspace(roundAxis_1.min(), roundAxis_1.max(), 60000) numberOfDeadNodesAxis_smooth_1 = spline(roundAxis_1, numberOfDeadNodesAxis_1, roundAxis_new_1) plt.text(firstDeadNodeRound_1 - 350, 10, firstDeadNodeRound_1) plt.text(lastDeadNodeRound_1, 305, lastDeadNodeRound_1) plt.plot(roundAxis_new_1, numberOfDeadNodesAxis_smooth_1, 'b', label='BMA MAC') roundAxis_2 = list(map(int, listt_2[0].strip().split(' '))) numberOfDeadNodesAxis_2 = list(map(int, listt_2[1].strip().split(' '))) firstDeadNodeRound_2 = findFirstDeadNodeRound(roundAxis_2, numberOfDeadNodesAxis_2) lastDeadNodeRound_2 = findLastDeadNodeRound(roundAxis_2, numberOfDeadNodesAxis_2) roundAxis_2 = roundAxis_2[0:firstDeadNodeRound_2 // 2:10] + roundAxis_2[firstDeadNodeRound_2 // 2:6000:75] numberOfDeadNodesAxis_2 = numberOfDeadNodesAxis_2[ 0:firstDeadNodeRound_2 //
[51069435]]) # print(s) x = solve(m, s) t = np.array([[11321], [12223], [15707], [14070], [12152], [11502]]) y = solve(m, s1) for i in range(0, 6): y[i] = trans(str(y[i][0])) # print(x) print(y) plt.ylabel('时段内的平均等待时间/分钟', size=15) plt.xlabel('时间段', size=15) print(m.dot(t)) for i in range(0, 6): print(s1[i][0] / sum(m[i]), end=',') xnew = np.linspace( 2, 22, 300) # 300 represents number of points to make between T.min and T.max y = spline(v, y, xnew) plt.plot(xnew, y, 'purple') # plt.plot(v,y,'purple') plt.xlim(0, 24, 4) plt.ylim(0, 200) plt.xticks(range(0, 28, 4)) plt.show()
def make_segments(count, thresh, blur, image, path, newpath, actual_contours_path, segment_path): # print image.shape # fo = open("processing.txt", "a") # print path coordinates_of_segments = {} temp_coordinates = [] ret, th = cv2.threshold(blur, thresh, 255, cv2.THRESH_BINARY) # individual = 'croppedSegments/' xpath = newpath imsave(newpath + '/thresholded_image.jpg', th) filename = list(path.split('/')) filename = filename[-1] filename = list(filename.split('\\')) filename = filename[-1] # print filename imsave(thresholded_path + filename, th) cnts, hierarchy = cv2.findContours(th, 1, 2) thresholded_image = cv2.cv.LoadImage(newpath + '/thresholded_image.jpg') pathses = newpath + "/size.txt" # delete_file(newpath + '/thresholded_image.jpg') actual_image = cv2.imread(path) file_name = [] file_name = path.split("\\") file = file_name[-1] coordinates_of_segments[file] = [] # print file,thresh loaded_image = cv2.cv.LoadImage(path) rect_image = actual_image contour_list = [] mask = np.ones(image.shape[:2], dtype="uint8") * 255 # loop over the contours number = 0 red_number = 0 green_number = 0 global mc_and_dc_list segment_list = [] original_segment_list = [] coordinates_list = [] xmin = 10000 ymin = 10000 xmax = 0 ymax = 0 w1 = 0 h1 = 0 counters = 0 for c in cnts: approx = cv2.approxPolyDP(c, 0.009 * cv2.arcLength(c, True), True) area = cv2.contourArea(c) if ((len(approx) > 8) & (area < 4000) & (area > 100)): number += 1 global w, h center, angle, w, h, x1, y1, x2, y2 = get_coordinates( actual_image, c, coordinates_list) if (x1 - w < xmin): xmin = x1 - w if (x2 + w > xmax): xmax = x2 + w if (y1 - h < ymin): ymin = y1 - h if (y2 + h > ymax): ymax = y2 + h w1 += w h1 += h counters = counters + 1 # print(x1-w,y1-h,x2+w,y2+h,counters,h1,h) crop_th = crop_image(thresholded_image, center, angle, w, h) crop = crop_image(loaded_image, center, angle, w, h) image = crop # create_dir(individual+file+'/') cv2.cv.SaveImage(newpath + '/' + 'contour_' + str(number) + '.jpg', crop_th) cv2.cv.SaveImage( actual_contours_path + 'contour_' + str(number) + '.jpg', crop) # cv2.cv.SaveImage(individual+ file+'/' + str(random.randint(1,50000)) + '.jpg',crop) temp_image = PIL.Image.open(newpath + '/' + 'contour_' + str(number) + '.jpg') original_temp_image = PIL.Image.open(actual_contours_path + 'contour_' + str(number) + '.jpg') segment_list.append(temp_image) original_segment_list.append(original_temp_image) # image = original_temp_image image = skimage.color.rgb2gray( skimage.io.imread(actual_contours_path + 'contour_' + str(number) + '.jpg')) delete_file(newpath + '/' + 'contour_' + str(number) + '.jpg') delete_file(actual_contours_path + 'contour_' + str(number) + '.jpg') total = [] h = image.shape[0] w = image.shape[1] for x in xrange(h): s = 0 for y in xrange(w): s += image[x][y] total.append(s) avg = [sum(total) / len(total)] * len(total) T = list(range(len(total))) t = np.array(T) power = np.array(total) totalnew = np.linspace(t.min(), t.max(), len(total)) power_smooth = spline(t, power, totalnew) # ax = axs[1] sigma = 3 x_g1d = gaussian_filter1d(totalnew, sigma) y_g1d = gaussian_filter1d(power_smooth, sigma) index = [] temp = 0 for i in xrange(1, len(y_g1d) - 1): if y_g1d[i] > y_g1d[i - 1] and y_g1d[i] > y_g1d[i + 1]: index.append(i) if len(index) == 0: x_g1d = totalnew y_g1d = power_smooth for i in xrange(1, len(y_g1d) - 1): if y_g1d[i] > y_g1d[i - 1] and y_g1d[i] > y_g1d[i + 1]: index.append(i) cm = [] for x in xrange(1, len(index)): for y in xrange(x): if y_g1d[index[y]] < y_g1d[index[x]]: temp = index[y] index[y] = index[x] index[x] = temp if len(index) > 0: mx = [y_g1d[index[0]]] * len(total) # plt.plot(t,mx) cent1 = index[0] # ax=axs[0] cm1 = (w / 2, cent1) cv2.circle(image, cm1, 3, (0, 1, 0), -1) cm.append(cm1) DCcount = 0 if len(index) > 1 and y_g1d[index[1]] > avg[0] and abs( y_g1d[cent1] - y_g1d[index[1]]) < abs(y_g1d[index[1]] - y_g1d[int(avg[0])]): # if len(index)>1 and total[index[1]]>avg[0] and abs(cent1-index[1])>h/a and abs(total[cent1]-total[index[1]])<abs(total[index[1]]-total[int(avg[0])]): mx2 = [y_g1d[index[1]]] * len(total) # plt.plot(t,mx2) cent2 = index[1] cm2 = (w / 2, cent2) cv2.circle(image, cm2, 3, (0, 1, 0), -1) cm.append(cm2) DCcount += 1 if len(cm) == 2: red_number += 1 rect = cv2.minAreaRect(c) box = cv2.cv.BoxPoints(rect) temp_box = list(box) temp_box.append((1, 1)) box = np.int0(box) temp_coordinates.append(temp_box) # print "coordinates of dc" # print box cv2.drawContours(actual_image, [box], 0, (0, 0, 255), 2) else: green_number += 1 rect = cv2.minAreaRect(c) box = cv2.cv.BoxPoints(rect) temp_box = list(box) temp_box.append((0, 0)) box = np.int0(box) temp_coordinates.append(temp_box) # print "coordinates of mc" # print box cv2.drawContours(actual_image, [box], 0, (0, 255, 0), 2) f = open(pathses, 'w') ##print(w1,h1,counters,w1/(counters),h1/(counters)) #print(pathses) #print("dsfj sdjfhjdsfdsfjdsjf jdsfjds jfdsjjf sjfdjsfjdsh") f.write('{} {} {} {} {} {}'.format(xmin, ymin, xmax, ymax, w1 / (counters), h1 / (counters))) f.close() coordinates_of_segments[file] = temp_coordinates cv2.imwrite(segment_path + filename, actual_image) time.sleep(0.30) #cv2.waitKey(50) print "^^^^^^^^^^^^^^", time.time() i = count + 1 # while soft_sheet['A'+str(i)]==None: soft_sheet['A' + str(i)] = file soft_sheet['B' + str(i)] = number if not DCcount == 0: soft_sheet['C' + str(i)] = DCcount pathses, tail = os.path.split(pathses) pathses, tail = os.path.split(pathses) soft_data.save('data.xlsx') mc_and_dc_list.append([red_number, green_number, number, tail[8:]]) return mc_and_dc_list, number, segment_list, original_segment_list, coordinates_list, coordinates_of_segments
ff=0 qq=float(1) for i in range(M): ff=ff+W[i]*qq qq=qq*xx ew1=0.0 for i in range(100): ew1=ew1+(ff[i]-YY[i])**2 eww1=np.sqrt(ew1/100) #显示误差率 print("训练集误差率:"+str(eww)) print("测试集误差率:"+str(eww1)) # 画出这些点 xnew = np.linspace(X.min(),X.max(),300) power_smooth = spline(X,test,xnew) xnew1 = np.linspace(x.min(),x.max(),300) power_smooth1 = spline(x,f,xnew1) pt.plot(xnew,power_smooth,color="blue",label='sin(2*pi*x)') pt.plot(xnew1,power_smooth1,color="red",label='fx') pt.plot(X,Y,linestyle='',marker='.',label='traindata') pt.legend(bbox_to_anchor=(1.0, 1), loc=1, borderaxespad=0.) pt.show()
noise_.append(test_noise) else: noise_.append(0) # Record data y_.append(y) setpoints_.append(pid.set_point) t_.append(i) outs_.append(output) # Let some time pass time.sleep(0.01) # Smooth out rough edges t_sm = np.linspace(min(t_), max(t_), 400) y_sm = spline(t_, y_, t_sm) outs_sm = spline(t_, outs_, t_sm) fig = plt.figure() plt.subplot(2, 1, 1) plt.plot(t_sm, y_sm, label='y') plt.plot(t_, setpoints_, label='Setpoint') plt.grid(True) plt.xlim([0, max(t_)]) plt.title("PID controller on y variable") plt.legend() plt.subplot(2, 1, 2) plt.plot(t_sm, outs_sm, label='u', color='red') plt.plot(t_, noise_, label='Noise', color='black') plt.grid(True) plt.xlim([0, max(t_)]) plt.ylim([-3, test_noise + 1])
table.finalize(heavy=False, divider=True) #table.print_header() print print 'Most recent '+str(trend_days)+'-day savings trend:', '$' + format_balance(trends[-1]/12) + ' per month,', \ '$' + format_balance(trends[-1]) + ' per year' (x_data, total_balances_data, checking_balances_data, savings_balances_data, credit_balances_data, bank_balances_data, total_balance_diffs, bank_balance_diffs, credit_balance_diffs, bank_rises, bank_small_falls, bank_large_falls) = collapsed_calculated if plot_collapse_days else calculated ##### Plot output x_smooth = np.linspace(min(x_data), max(x_data), 1000) bank_balances_smooth = spline(x_data, bank_balances_data, x_smooth) total_balances_smooth = spline(x_data, total_balances_data, x_smooth) checking_balances_smooth = spline(x_data, checking_balances_data, x_smooth) savings_balances_smooth = spline(x_data, savings_balances_data, x_smooth) credit_balances_smooth = spline(x_data, credit_balances_data, x_smooth) xs = x_data bank_balances_ys = bank_balances_data total_balances_ys = total_balances_data checking_balances_ys = checking_balances_data savings_balances_ys = savings_balances_data credit_balances_ys = credit_balances_data smooth = False if smooth:
def smooth(xspan, data): x_points = np.linspace(xspan[0], xspan[-1], 25) #change number for 'smoothness' level smooth_points = spline(xspan, data, x_points) return (x_points, smooth_points)
def plotScatters(L_f, K_t, lo_i=0, outputDir="/Users/jimmy/Code/stochfilaments/output/", saveDir="/Users/jimmy/Desktop/"): #ANALYTIC DATA #lo for cross-linkers only (Kt=0.01) loa_cl = [ 0, 0.1295, 0.6966, 2.7600, 9.2886, 26.4296, 59.7827, 72.1158, 51.0522, 37.9080, 29.8891, 24.6716, 21.0468, 18.3768, 16.3464, 14.7404 ] #Caclulate steady-state lo_ss = [] for energy in ref_e: lo_ss.append(energy * common.kT * (1.0 / (1.0 + (v / v_b) * math.exp(-energy))) / (2.0 * 10.0 * K_t)) mpl.rcParams['axes.color_cycle'] = ['y', 'k', 'darkgreen'] #mpl.rcParams['axes.color_cycle'] = ['b', 'g', 'r', 'c'] #mpl.rcParams['axes.color_cycle'] = ['darkorange', 'blueviolet', 'brown'] numRuns = 250.0 #open data l = pickle.load( open(outputDir + "/meanl-Lf%0.3f-Kt%0.3f.p" % (L_f, K_t), "rb")) err_l = pickle.load( open(outputDir + "/errmeanl-Lf%0.3f-Kt%0.3f.p" % (L_f, K_t), "rb")) l_s = pickle.load( open(outputDir + "/meanls-Lf%0.3f-Kt%0.3f.p" % (L_f, K_t), "rb")) err_ls = pickle.load( open(outputDir + "/errmeanls-Lf%0.3f-Kt%0.3f.p" % (L_f, K_t), "rb")) n = pickle.load( open(outputDir + "/meann-Lf%0.3f-Kt%0.3f.p" % (L_f, K_t), "rb")) err_n = pickle.load( open(outputDir + "/errmeann-Lf%0.3f-Kt%0.3f.p" % (L_f, K_t), "rb")) k_minus = ref_k_minus * L_f initVal = l[0] * K_t initErr = err_l[0] #Plot overlap #plt.figure(4, figsize = (2,2)) #pyplot.locator_params(nbins=4) #plt.errorbar(ref_e, l, fmt='o-', yerr=err_l, label=r'$\mathsf{K_t = %g \/ pN / nm}$' % (K_t)) #plt.xlabel(r'$\mathsf{\epsilon\/ (k_bT)}$', fontsize=12) #plt.ylabel(r'$\mathsf{\langle l_{overlap} \rangle\/(nm)}$', fontsize=12) #plt.savefig(saveDir + '/lmeanvsg0.pdf', format='pdf') #Plot force plt.figure(5, figsize=(2, 2)) pyplot.locator_params(nbins=8) #plt.ylim((-0.1,5.5)) #plt.xlim((3,15)) #smooth data ehat = np.linspace(min(ref_e), max(ref_e), 100) lhat = spline(ref_e, l, ehat) lhat_cl = spline(ref_e, loa_cl, ehat) lhat_ss = spline(ref_e, lo_ss, ehat) print[(x - lo_i) * K_t for x in l] plt.plot(ehat, [(x - lo_i) * K_t for x in lhat], markersize=2, linewidth=2.0, label=r'$\mathsf{k_{off}^{cl} = %g \/ s^{-1}}$' % (k_minus)) #plt.plot(ehat, [(x - lo_i) * K_t for x in lhat_cl], 'k-', markersize=1, linewidth=2.0) #plt.plot(ehat, [(x - lo_i) * K_t for x in lhat_ss], 'k--', markersize=3, linewidth=2.0) plt.xlabel(r'$\mathsf{\epsilon\/ (k_bT)}$', fontsize=12) plt.ylabel(r'$\mathsf{\langle F \rangle\/(pN)}$', fontsize=12) plt.savefig(saveDir + '/fmeanvsg0.pdf', format='pdf')
import pandas as pd from scipy.interpolate import UnivariateSpline as spline data = pd.read_csv("input", sep="\t") data.index = range(data.shape[0]) data.columns = ["y"] data["x"] = range(data.shape[0]) # position of the missing price pos_missing = data.y.str.startswith("Missing") data_missing = data[pos_missing] data_training = data[pos_missing == False] spline_model = spline(data_training.x, data_training.y, k=3, s=3) pred_price = spline_model(data_missing.x) print(*pred_price, sep="\n")
tong = tong + in_image[i, j] luminance.append([i, tong // B[i][3]]) axisx = [] axisy = [] deriy = [] # print luminance print luminance size = len(luminance) deriy.append(0) for i in range(0, len(luminance)): axisx.append(luminance[i][0]) axisy.append(luminance[i][1]) xnew = np.linspace(axisx[0], axisx[359], 360) power_smooth = spline(axisx, axisy, xnew) for i in range(1, size - 1): deriy.append((luminance[i + 1][1] - luminance[i - 1][1]) / 6) deriy.append((luminance[size - 1][1] - luminance[size - 2][1]) / 3) # in ra vi tri vi # for i in range(0, 360): # if (deriy[i] == min(deriy)): # print i # plt.plot(axisx, axisy, 'r'), plt.plot(xnew, power_smooth, 'b') plt.xlabel('Bandwidth Heigh (Image Heigh)') plt.ylabel('Intensity Value') plt.show()
def create_graphs_NN(X, Y, learning_rate, max_iterations, dataset_name, random_state): train_accuracies = list() test_accuracies = list() train_times = list() predict_times = list() smooth = np.linspace(max_iterations.min(), max_iterations.max(), 300) for alpha in learning_rate: train_acc_list_iter = list() test_acc_list_iter = list() time_train_list_iter = list() time_predict_list_iter = list() for max_iter in max_iterations: nn = MLPClassifier(learning_rate_init=alpha, activation='logistic', solver='sgd', max_iter=max_iter) # Create Training and Testing Data # train_X, test_X, train_Y, test_Y = train_test_split(X, Y, test_size=.20) kfold = KFold(n_splits=5, shuffle=True) train_acc_list = list() test_acc_list = list() time_train_list = list() time_predict_list = list() for train_index, test_index in kfold.split(X): train_X, test_X = X[train_index], X[test_index] train_Y, test_Y = Y[train_index], Y[test_index] # Create and Train Model # Train and Get Time time_start = time.time() nn.fit(train_X, train_Y) time_train = time.time() - time_start time_start = time.time() predict_Y_test = nn.predict(test_X) time_predict = time.time() - time_start predict_Y_train = nn.predict(train_X) test_acc = accuracy_score(test_Y, predict_Y_test) train_acc = accuracy_score(train_Y, predict_Y_train) train_acc_list.append(train_acc) test_acc_list.append(test_acc) time_train_list.append(time_train) time_predict_list.append(time_predict) train_acc_list_iter.append(np.mean(train_acc_list)) test_acc_list_iter.append(np.mean(test_acc_list)) time_train_list_iter.append(np.mean(time_train_list)) time_predict_list_iter.append(np.mean(time_predict_list)) train_accuracies.append(train_acc_list_iter) test_accuracies.append(test_acc_list_iter) predict_times.append(time_predict_list_iter) train_times.append(time_train_list_iter) colors = plt.cm.tab20(np.linspace(0, 1, 19)) plot_names = list() for name in learning_rate: name = 'Learning Rate: %s' % name plot_names.append(name) plot_names = np.asarray(plot_names) for i in range(len(learning_rate)): # plt.plot(smooth_perc, 100 * spline(train_sizes, train_acc_list_iter[i], smooth)) plt.plot(smooth, 100 * spline(max_iterations, test_accuracies[i], smooth), color=colors[2 * (i - 1)]) # plt.plot(max_iterations, test_accuracies[i]) plt.legend(plot_names, loc='upper left', bbox_to_anchor=(1.05, 1)) plt.xlabel("Epochs") plt.ylabel("Accuracy (%)") plt.title('%s - Accuracy vs Epochs with Varying Learning Rates' % dataset_name) plt.show() for i in range(len(learning_rate)): plt.plot(smooth, spline(max_iterations, train_times[i], smooth), color=colors[2 * (i - 1)]) plt.legend(plot_names, loc='upper left', bbox_to_anchor=(1.05, 1)) plt.xlabel("Epochs") plt.ylabel("Time (sec)") plt.title('%s - Training Time vs Epochs with Varying Learning Rates' % dataset_name) plt.show() for i in range(len(learning_rate)): plt.plot(smooth, spline(max_iterations, predict_times[i], smooth), color=colors[2 * (i - 1)]) plt.legend(plot_names, loc='upper left', bbox_to_anchor=(1.05, 1)) plt.xlabel("Epochs") plt.ylabel("Time (sec)") plt.title('%s - Predicting Time vs Epochs with Varying Learning Rates' % dataset_name) plt.show()
rewardPerEpisode[0].append(i_episode) rewardPerEpisode[1].append(sum_reward) # print("eps", epsilon, "reward", sum_reward) # END OF EPISODE if i_episode % 100 == 0 and i_episode != 0 and len( lossPerTimeframe[0]) > 0: ## Plotting stuff plt.clf() xnew = np.linspace( np.array(rewardPerEpisode[0]).min(), np.array(rewardPerEpisode[0]).max(), float(EPISODES) / SMOOTH) power_smooth = spline(rewardPerEpisode[0], rewardPerEpisode[1], xnew) fig = plt.figure(0) ax1 = fig.add_subplot(111) ax1.plot(xnew, power_smooth, color='blue') plt.xlim(0, EPISODES) # plt.axis([0., EPISODES, 0., 500.]) plt.title(ENVIRONMENT) plt.xlabel('episode') plt.ylabel('reward') plt.savefig(ENVIRONMENT + '_reward') plt.clf() fig = plt.figure(1) ax1 = fig.add_subplot(111) ax1.semilogy(lossPerTimeframe[0], lossPerTimeframe[1], color='red') # ax1.loglog(lossPerTimeframe[0], lossPerTimeframe[1], color='red')
def cuveify(x, y, p=50): new_x = np.linspace(min(x), max(x), p) new_y = spline(x, y, new_x) return new_x, new_y
def plot_uncertainty_mip(group): table = group.E_1PeV.zenith_22_5 rec = DirectionReconstruction # constants for uncertainty estimation station = table.attrs.cluster.stations[0] r1, phi1 = station.calc_r_and_phi_for_detectors(1, 3) r2, phi2 = station.calc_r_and_phi_for_detectors(1, 4) R_list = get_median_core_distances_for_mips(group, range(1, 6)) figure() x, y, y2 = [], [], [] for N in range(1, 5): x.append(N) events = table.read_where('min_n134>=%d' % N) #query = '(n1 == N) & (n3 == N) & (n4 == N)' #vents = table.read_where(query) print len(events), errors = events['reference_theta'] - events['reconstructed_theta'] # Make sure -pi < errors < pi errors = (errors + pi) % (2 * pi) - pi errors2 = events['reference_phi'] - events['reconstructed_phi'] # Make sure -pi < errors2 < pi errors2 = (errors2 + pi) % (2 * pi) - pi #y.append(std(errors)) #y2.append(std(errors2)) y.append( (scoreatpercentile(errors, 83) - scoreatpercentile(errors, 17)) / 2) y2.append( (scoreatpercentile(errors2, 83) - scoreatpercentile(errors2, 17)) / 2) print "YYY", rad2deg( scoreatpercentile(errors2, 83) - scoreatpercentile(errors2, 17)) plot(x, rad2deg(y), '^', label="Theta") plot(x, rad2deg(y2), 'v', label="Phi") Sx = x Sy = y Sy2 = y2 print print "mip: min_n134, theta_std, phi_std" for u, v, w in zip(x, y, y2): print u, v, w print utils.savedata((x, y, y2)) # Uncertainty estimate x = [1, 2, 3, 4, 5] phis = linspace(-pi, pi, 50) phi_errsq = mean(rec.rel_phi_errorsq(pi / 8, phis, phi1, phi2, r1, r2)) theta_errsq = mean(rec.rel_theta1_errorsq(pi / 8, phis, phi1, phi2, r1, r2)) y = TIMING_ERROR * std_t(x) * sqrt(phi_errsq) y2 = TIMING_ERROR * std_t(x) * sqrt(theta_errsq) mc = my_std_t_for_R(data, x, R_list) for u, v in zip(mc, R_list): print v, u, sqrt(u**2 + 1.2**2), sqrt((.66 * u)**2 + 1.2**2) mc = sqrt(mc**2 + 1.2**2) y3 = mc * sqrt(phi_errsq) y4 = mc * sqrt(theta_errsq) nx = linspace(1, 4, 100) y = spline(x, y, nx) y2 = spline(x, y2, nx) y3 = spline(x, y3, nx) y4 = spline(x, y4, nx) plot(nx, rad2deg(y), label="Gauss Phi") plot(nx, rad2deg(y2), label="Gauss Theta") plot(nx, rad2deg(y3), label="Monte Carlo Phi") plot(nx, rad2deg(y4), label="Monte Carlo Theta") # Labels etc. xlabel("Minimum number of particles") ylabel("Angle reconstruction uncertainty [deg]") #title(r"$\theta = 22.5^\circ$") legend(numpoints=1) xlim(.5, 4.5) utils.saveplot() print graph = GraphArtist() graph.plot(Sx, rad2deg(Sy), mark='o', linestyle='only marks') graph.plot(Sx, rad2deg(Sy2), mark='*', linestyle='only marks') graph.plot(nx, rad2deg(y), mark=None, linestyle='dashed,smooth') graph.plot(nx, rad2deg(y2), mark=None, linestyle='dashed,smooth') graph.set_xlabel("Minimum number of particles") graph.set_ylabel(r"Reconstruction uncertainty [\si{\degree}]") graph.set_xticks(range(1, 5)) graph.set_ylimits(0, 32) artist.utils.save_graph(graph, dirname='plots') graph.plot(nx, rad2deg(y3), mark=None, linestyle='smooth') graph.plot(nx, rad2deg(y4), mark=None, linestyle='smooth') artist.utils.save_graph(graph, suffix='full', dirname='plots')
# for i in np.arange(0.0, 1.1, 0.1): # x1.append(i) # y1.append(i**2) # # # for i in np.arange(0.0, 1.1, 0.1): # x2.append(i) # y2.append(np.math.sqrt(i)) # xl=[1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5] # yl=[10.0, 4.44, 2.5, 1.6, 1.11, 0.82, 0.62, 0.49, 0.4, 0.33] x_f1 = np.array(x1) y_f1 = np.array(y1) xnew_f1 = np.linspace(x_f1.min(), x_f1.max(), 50) ynew_f1 = spline(x_f1, y_f1, xnew_f1) x_f2 = np.array(x1) y_f2 = np.array(y1) xnew_f2 = np.linspace(x_f2.min(), x_f2.max(), 50) ynew_f2 = spline(x_f2, y_f2, xnew_f2) plt.subplot(311) plt.plot(x1, y1, 'bo', x1, y1, 'k') plt.subplot(311) plt.plot(x2, y2, 'bo', x2, y2, 'k') plt.title('Grafik funkcije y(x)') # #plt.xlabel('x axis') # plt.ylabel('y osa')
def make_elevation_plots(DataDirectory, DEM_prefix, DEM_swathed, info_file, data_file, field_site, smoothing, OutputFigureName): """ Make nice plots of the elevations along the swath """ # Set up fonts rcParams['font.family'] = 'sans-serif' rcParams['font.sans-serif'] = ['Liberation Sans'] rcParams['font.size'] = 14 distance, MeanValues, MinValues, MaxValues, Nlines, info = read_all_data( DataDirectory, DEM_prefix, info_file, data_file) # add the XY Plot fig = plt.figure(1, figsize=(cm2inch(25), cm2inch(15))) # set ratios for subplots ax = fig.add_subplot(111) distance = np.array(distance) if (smoothing): MeanValues = np.array(MeanValues) MinValues = np.array(MinValues) MaxValues = np.array(MaxValues) smooth_k = 0.7 distance_interpolate = np.linspace(distance.min(), distance.max(), num=Nlines * smooth_k) MeanValues_smooth = spline(distance, MeanValues, distance_interpolate, order=1) MinValues_smooth = spline(distance, MinValues, distance_interpolate, order=1) MaxValues_smooth = spline(distance, MaxValues, distance_interpolate, order=1) ax.plot(distance_interpolate, MeanValues_smooth, 'k-', lw=0.75, label="Mean") ax.plot(distance_interpolate, MinValues_smooth, '-', c='gray', lw=0, label="Max/min") ax.plot( distance_interpolate, MaxValues_smooth, '-', c='gray', lw=0, ) ax.fill_between(distance_interpolate, MaxValues_smooth, MinValues_smooth, color='#D5D5D5') plt.xlabel('Distance along swath (m)') plt.ylabel('Elevation (m)') else: ax.plot(distance, MeanValues, 'k-', lw=0.75, label="Mean") ax.plot(distance, MinValues, '-', c='gray', lw=0, label="Max/min") ax.plot( distance, MaxValues, '-', c='gray', lw=0, ) ax.fill_between(distance, MaxValues, MinValues, color='#D5D5D5') plt.xlabel('Distance along swath (m)') plt.ylabel('Elevation (m)') temp = np.array(MinValues) temp2 = np.array(MaxValues) print( 'I am plotting the data, the minimum altitude is %s and the maximum is %s.' % (temp.min(), temp2.max())) plt.ylim(temp.min() - temp.min() / 20, temp2.max() + temp2.max() / 20) plt.xlim(0, distance.max()) plt.title(field_site) plt.legend(loc='upper right') # Save figure OutputFigureFormat = 'png' plt.savefig(DataDirectory + OutputFigureName + '.' + OutputFigureFormat, format=OutputFigureFormat, dpi=1000) #plt.tight_layout() plt.close()
trainX = numpy.reshape(trainX, (trainX.shape[0], look_back)) predictions = model.predict(h2o.H2OFrame(trainX)) time.sleep(1) predictions = predictions.as_data_frame(use_pandas=True) predictions = numpy.array(predictions) dataset = numpy.append(dataset, predictions[-1]) dataset = numpy.reshape(dataset, (dataset.shape[0], 1)) dataset = scaler.inverse_transform(dataset) predictions = scaler.inverse_transform(predictions) # To plot whole predictions plt.style.use('ggplot') x = numpy.arange(0, len(predictions)) y = numpy.array(dataset[len(dataset) - len(predictions):, ]) x_smooth = numpy.linspace(x.min(), x.max(), len(predictions) * 20) y_smooth = spline(x, y, x_smooth) z_smooth = spline(x, predictions, x_smooth) plt.plot(x_smooth, y_smooth) plt.plot(x_smooth, z_smooth, 'g') # To plot forecast length # x = numpy.arange(len(dataset) - forecast_length - 1, len(dataset)) # y = dataset[len(dataset) - forecast_length - 1:, ] # x_smooth = numpy.linspace(x.min(), x.max(), 500) # y_smooth = spline(x, y, x_smooth) # plt.plot(x_smooth, y_smooth, 'g') print(dataset) plt.show() h2o.remove_all()
# rotate array data[i] = roll(data[i], -1) data[i][-1] = num count = num_p - 1 else: data[i][count] = num # gyro pl.subplot(211) if (bar): pl.bar(0, data[1][count], color='b') pl.bar(1, data[2][count], color='g') pl.bar(2, data[3][count], color='r') pl.axis([0, 3, -300, 300]) elif (smooth): pl.plot(T, spline(t, data[1], T), 'b') pl.plot(T, spline(t, data[2], T), 'g') pl.plot(T, spline(t, data[3], T), 'r') pl.axis([0, num_p, -300, 300]) else: pl.plot(t, data[1], 'b') pl.plot(t, data[2], 'g') pl.plot(t, data[3], 'r') pl.axis([0, num_p, -300, 300]) pl.title('Gyroscope') pl.ylabel('deg/s') # accel pl.subplot(212) if (bar): pl.bar(0, data[4][count], color='b')
def createfile(dest): """ The script creates a text file at the passed in location, names file based on date """ date_format = t.localtime(t.time()) today = ' %d_%d_%d'%(date_format[2],date_format[1],date_format[0]) name_date=' %d_%d_%d.txt'%(date_format[2],date_format[1],date_format[0])#assigning the file name andformat ##FileName = name_of_practical + Day_Month_Year name_of_practical = raw_input('Enter practical name: ') if not(path.isfile(dest+name_of_practical + name_date)):#checks if file already exists f = open(name_of_practical + name_date,'w') print("\nBiochemistry electronic write-up system\n") name = raw_input("Enter your name: ") f.write("Name: ") f.write(name) f.write('\n') Reg_number = raw_input("Enter your registration number: ") f.write("Reg_number: ") f.write(Reg_number) f.write('\n') program = raw_input("Enter your program name: ") f.write("Program: ") f.write(program) f.write('\n') f.write("Date: ") f.write(today) f.write('\n') coordinator = raw_input("Enter coordinator names: ") f.write("Coordinator(s): ") f.write(coordinator) f.write('\n'*2) f.write('\t\t\t') f.write(name_of_practical) f.write('\n'*2) f.write("Introduction\n") f.write(raw_input("\nEnter the introduction of the experiment:\n")) f.write('\n'*2) f.write("Materials and methods\n") f.write(raw_input("\nName the materials and methods used in the experiment:\n")) f.write('\n'*2) ## f.write("Recording results\n") print("Recording results\n") ## while True: try: upper_bound=int(raw_input("Enter the total number of recordings: ")) while upper_bound <=4:#this is to make sure that all values entered are positive and atleast 5 print("please try again, you need a minimum of 5 readings")#the error message for negative numbers and values less than 5 upper_bound=int(raw_input("Enter the total number of x and y coordinates: ")) break except ValueError:#this lets the program know what to do with with the errors by entering non-numeric data print("Non-numeric characters are invalid, please enter a positive number for the upper bound of atleast 5") # x=[] x_axis=raw_input("What is the variable for the x-axis: ") for i in range (upper_bound): while True: try: x.append(float(raw_input("Enter the value for the x-axis: "))) break except ValueError:#this lets the program know what to do with with the errors by entering non-numeric data print("Non-numeric characters are invalid, please enter numbers") print(x) list_x = np.array(x) f.write('Results for ') f.write(x_axis) f.write('\n') f.write(str(x)) f.write('\n') ## y = [] y_axis = raw_input("\nwhat is the the variable for the y-axis: ") for i in range (upper_bound): while True: try: y.append(float(raw_input("Enter the value for the y-axis: "))) break except ValueError:#this lets the program know what to do with with the errors by entering non-numeric data print("Non-numeric characters are invalid, please enter numbers") print(y) list_y = np.array(y) f.write('\nResults for ') f.write(y_axis) f.write('\n') f.write(str(y)) f.write('\n'*2) ###### # Label the x and y axes and title the graph. xlabel(x_axis) ylabel(y_axis) title(name_of_practical) x_smooth = np.linspace(list_x.min() ,list_x.max(),300) y_smooth = spline(list_x, list_y, x_smooth) plt.plot(x_smooth,y_smooth) plt.show() f.write("Analysis\n") f.write(raw_input("\nEnter the analysis of the experiment:\n")) f.write("\n"*2) f.write("Discussion\n") f.write(raw_input("\nEnter the discussion of the experiment:\n")) f.write("\n"*2) f.write("Conclusion\n") f.write(raw_input("\nEnter the conclusion of the experiment:\n")) f.write("\n"*2) f.write("References\n") f.write(raw_input("\nEnter the refrences of the experiment:\n")) f.write("\n"*2) f.close()