def EVal(A): # A is a 2x2 matrix #Create an If statement that will return an appropriate error if A is not 2x2 if len(A)!=2: sol="Matrix A is not 2x2 - cannot determine eigenvalues" elif len(A[0])!=2: sol="Matrix A is not 2x2 - cannot determine eigenvalues" elif len(A[1])!=2: sol="Matrix A is not 2x2 - cannot determine eigenvalues" #Solve the characteristic equation else: a=1 b=-A[0][0]-A[1][1] c=(A[0][0]*A[1][1])-(A[0][1]*A[1][0]) dis=b**2-4*a*c if dis>=0: #Find a solution to (A-lambda*I)x=0 for both solutions #Normalize your solutions lambda1=(-b+np.sqrt(dis))/2 lambda2=(-b-np.sqrt(dis))/2 if A[0][0]-lambda1==0 and A[1][0]==0: v1=np.aray([0,1]) else: v1=np.array([-A[0][1]/(A[0][0]-lambda1),1]) if A[0][0]-lambda2==0 and A[1][0]==0: v2=np.array([0,1]) else: v2=np.array([-A[0][1]/(A[0][0]-lambda2),1]) v1_mag=m.sqrt(v1[0]**2+v1[1]**2) v2_mag=m.sqrt(v2[0]**2+v2[1]**2) v1_norm=v1/v1_mag v2_norm=v2/v2_mag sol=[lambda1,v1_norm],[lambda2,v2_norm] else: re=-b/2 im=(np.sqrt(-dis))/2 lambda1=np.complex(re,im) lambda2=np.complex(re,-im) if A[0][0]-lambda1==0 and A[1][0]==0: v1=np.aray([0,1]) else: v1=np.array([-A[0][1]/(A[0][0]-lambda1),1]) if A[0][0]-lambda2==0 and A[1][0]==0: v2=np.array([0,1]) else: v2=np.array([-A[0][1]/(A[0][0]-lambda2),1]) sol=[lambda1,v1],[lambda2,v2] #Return the solution in the form [lambda_1,v_1],[lambda_2,v_2] return sol
def intial_centroid(X, K): centroid_algorithm = input( 'which do you use method computing initial centroid ?(practice,random) :' ) if centroid_algorithm == 'random': centroid = np.zeros((K, X.shape[1])) for i in range(K): index = np.random.choice(range(X.shape[0])) centroid[i, :] = X[index, :] if centroid_algorithm == 'practice': centroid = np.zeros((K, X.shape[1])) centroid[0, :] = np.aray([0, 0]) centroid[1, :] = np.aray([10, 10]) return centroid
def asColumnmatrix(X): if len(X) == 0: return np.aray([]) mat = np.empty((X[0].size, 0), dtype=X[0].dtype) for col in X: mat = np.hstack((mat, np.asarray(col).reshape(-1, 1))) return mat
def condition(dens, ind, A): if (dens['bandwidth'].shape[1] > 2 * dens['N']): wNew1 = np.zeros(1, getNpts(dens)) for i in range(0, getNpts(dens)): ktmp = kde(getPoints(dens, i), getBW(dens, i), 1, getType(dens)) wNew1[i] = evaluate(marginal(ktmp, ind), A[ind], 0) else: bw = getBW(dens, 0) if (m_size(A)[1] > 1): # temp fix wNew1 = evaluate(kde(A[ind, 0], bw[ind], 1, getType(dens)), marginal(dens, ind), 0) else: if (A.size == 1): wNew1 = evaluate(kde(A, bw[ind], 1, getType(dens)), marginal(dens, ind), 0) else: wNew1 = evaluate(kde(A[ind, 0], bw[ind], 1, getType(dens)), marginal(dens, ind), 0) wNew = wNew1 * getWeights(dens) pts = getPoints(dens) if (dens['bandwidth'].shape[1] > 2 * dens['N']): bw = getBW(dens, np.aray(1, getNpts(dens))) else: bw = getBW(dens, 1) newInd = np.setdiff1d(np.arange(getDim(dens)), ind) pp = kde(pts[newInd, :], bw[newInd, :], wNew, getType(dens)) return pp
def make_coordinates(image, line_parameters): slope, intercept = line_parameters y1 = 300 y2 = 120 x1 = int((y1 - intercept) / slope) x2 = int((y2 - intercept) / slope) return np.aray([x1, y2, x2, y2])
def sample_subgoals(env, model, path_index, policy_loss, num_subgoals=3): cx = Variable(torch.zeros(1, model.lstm_size)) hx = Variable(torch.zeros(1, model.lstm_size)) path_state = env.ep.stats.path if len(env.ep.stats.path) - path_index > num_subgoals: subgoal_state_indices = np.random.choice(range(path_index + 1, len(env.ep.stats.path)), size=num_subgoals, replace=False) subgoal_states = [ env.ep.stats.path[index] for index in subgoal_state_indices ] else: return policy_loss subgoals = [state.hidden_state for state in subgoal_states] dist_to_subgoals = [(subgoal_index - (path_index)) for subgoal_index in subgoal_state_indices] for i in range(len(subgoals)): obs, action, reward = env.ep.stats.obs_action_Reward[ subgoal_state_indices[i]] state_obs = obs[0][:env.str_len] subgoal = subgoals[i] if np.array_equal(state_obs, subgoal): continue h_d = re.EpState.get_h_d(state_obs, subgoal) obs_input = np.concatenate((state_obs, subgoal, np.aray([h_d]))) obs_input = torch.from_numpy(obs_input).float().unsqueeze(0) probs = policy(obs_input) m = Categorical(probs) prob = probs[0][action].item() action = torch.Tensor([action]) log_prob = m.log_prob(action) reward = reward + her_coeff * (prob)**dist_to_subgoals[i] policy_loss = policy_loss - reward return policy_loss
def get_xyrz(self, data, key): # Get data if key in self.seed_keys: pos = LoadedData(data=self.data).get_seeds(key=key, idx=self.idx) elif key in self.streamer_keys: pos = self.dirty_get(self.data, key, self.idx) else: logger.error('Warning! Invalid key ({})'.format(key)) return np.aray([]), np.aray([]), np.aray([]), np.aray([]) x = pos[0, :] y = pos[1, :] z = pos[2, :] r = np.sqrt(pos[0, :]**2 + pos[1, :]**2) return x, y, r, z
def generateValidData(batch_size, data=[]): while True: print('generateData...') valid_data = [] valid_label = [] batch = 0 for i in range(len(data)): url = data[i] batch += 1 img = load_img(filepath + '/trains/' + url) # print(img) valid_data.append(img) label = load_img(filepath + '/labels/' + url) # 从二维转换为三维,也可以直接用rs读取(直接三维数据) label = img_to_array(label) valid_label.append(label) # 对于一个batch进行打包,使用yield生成 if batch % batch_size == 0: valid_data = np.array(train_data) # 这里对于标签数据进行处理,不是很明白。。。 valid_label = np.aray(train_label).flatten() # 拍平 valid_label = labelencoder.transform( train_label) # 编码,这个方法还需要掌握 valid_label = to_categorical(train_label, num_classes=n_label) # 编码输出便签 valid_label = train_label.reshape( (batch_size, img_w, img_h, n_label)) yield (valid_data, valid_label) train_data = [] train_label = []
def test_condense(test, number): testresults = [] for i in tqdm((range(np.size(test, 0))) / number): sum = 0 for j in range(number): sum += test[i * number + j] testresults.append(sum / number) return np.aray(testresults)
def process_image_dsift(imagename, resultname, size=20, steps=10, force_orienation=False, resize=None): """Process an image with densely sampled SIFT descriptors and the save the results to file. INPUT: imagename (string): Input image file location. resultname (string): Output image file location. size (int): Feature size. steps (int): Steps between locations. force_orientation (bool): If false all iamges are assumed oriented upwards. resize (tuple): Required image size. OUTPUT: Dense sift representation of image. """ im = Image.open(imagename).convert('L') if resize != None: im = im.resize(resize) m, n = im.size if imagename[-3:,] != 'pgm': # create a pgm file im.save('tmp.pgm') imagename = 'tmp.pgm' # create frames and save to temporary file scale = size / 3.0 x, y = np.meshgrid(range(steps, m, steps), range(steps, n, steps)) xx, yy = x.flatten(), y.flatten(), frame = np.aray([xx, yy, scale * np.ones(xx.shape[0]), np.zeros(xx.shape[0])]) np.savetxt = ('tmp.frame', frame.T, fmt='%03.3f') if force_orienation: cmmd = str('sift ' + imagename + ' --output= ' + resultname + ' --read-frames = tmp.frame --orientations') else: cmmd = str('sift ' + imagename + ' --output= ' + resultname + ' --read-frames = tmp.frame') os.system(cmmd) print('processed', imagename, 'to', resultname)
def __ortho__(v): """ Orthogonal sample symmetry to a vector (v) in 3D """ v1 = np.aray([a[0], a[1], a[2]]) v2 = np.array([-a[0], a[1], a[2]]) v3 = np.array([a[0], -a[1], a[2]]) v4 = np.array([-a[0], -a[1], a[2]]) v5 = v1.copy()* -1 v6 = v2.copy()* -1 v7 = v3.copy()* -1 v8 = v4.copy()* -1 return v1, v2, v3, v4
def ens_tau(pars=None, lmax_in=1535, ntest=10): global lmax if pars is None: parr = np.arange(0.01, 0.1, 0.01) else: parr = np.aray(pars) print('tau=', parr) dir = ('./ensemble_lmax%d_tau_' % lmax) + time.strftime('%Y-%m-%d_%X') if not os.path.isdir(dir): os.mkdir(dir) print(dir, 'has been created.') for par_in in parr: test_ensemble(pname='tau', par_in=par_in, ntest=ntest, dir=dir)
def softmax(x): def loadGloveModel(gloveFile): print ("Loading Glove Model") f = open(gloveFile,'r',encoding='utf8') model = {} for line in f: splitLine = line.split() word = splitLine[0] embedding = [float(val) for val in splitLine[1:]] model[word] = embedding print ("Done.",len(model)," words loaded!") return model model = loadGloveModel("utils/datasets/glove.6B.50d.txt") frog = np.array(model["frog"]) cat = np.aray(model["cat"]) lion = np.array(model["lion"]) frog_lion = frog.T.dot(lion) cat_lion = cat.T.dot(lion) print("Frog and lion are closer", frog_lion) print("Cat and lion are closer", cat_lion) words = "I am talking about a pet." average = np.zeros_like(np.array(model["dog"])) for w in words.split(): if w.lower() in model.keys(): average +=np.array(model[w.lower()]) average = average/len(w) predCat = average.T.dot(cat) predCar = average.T.dot(np.array(model["car"])) #probabilities catProb = np.exp(predCat)/(np.exp(predCat)+np.exp(predCar)) carProb = np.exp(predCar)/(np.exp(predCat)+np.exp(predCar)) print("Cat: ",catProb,", Dog: ",carProb)
def Check_Predictions(sql=False, num=25): from Webscraping import USER from MachineLearning import Model path = USER / r'Dropbox\ん' model = Model('deepdanbooru.hdf5') if sql: from Webscraping import CONNECT MYSQL = CONNECT() SELECT = f''' SELECT full_path(path), tags, type FROM imagedata WHERE SUBSTR(path, 32, 5) IN ('.jpg', '.png') ORDER BY RAND() LIMIT {num} ''' for image, tags, type_ in MYSQL.execute(SELECT, fetch=1): tags = sorted(tags.split()) image = path / image prediction = model.predict(image) similar = set(tags) & set(prediction) else: import cv2 import numpy as np from PIL import Image from random import choices glob = list(path.glob('[0-9a-f]/[0-9a-f]/*jpg')) for image in choices(glob, k=num): prediction = model.predict(image) image_ = np.aray(Image.open(image)) image_ = cv2.cvtColor(image_, cv2.COLOR_RGB2BGR) cv2.imshow(prediction, image_) cv2.waitKey(0)
def stack_one_step(q_mb_list, q_mf_list, gamma, env, evaluation_budget, treatment_budget, argmaxer, bootstrap_weight_list, intercept=False): bootstrap_weight_correction_arr = compute_bootstrap_weight_correction(bootstrap_weight_list) y = np.hstack(env.y).astype(float) X = np.vstack(env.X) X_raw = np.vstack(env.X_raw) phi = np.zeros((0, 2)) # Get targets and features (replicates of correction-weighted y's and X's) # (phi refers to q functions as features) for b, bootstrap_weight_correction_b in enumerate(bootstrap_weight_correction_arr): target_b= np.multiply(y, bootstrap_weight_correction_b) phi_b = np.column_stack((q_mb_list[b]())) # Get targets (replicates of correction-weighted y's) target = np.array([np.multiply(y, bootstrap_correction_b.flatten()) for bootstrap_correction_b in bootstrap_weight_correction_arr]) target = target.flatten() # Get features (replicate sof correction-weighted X's) features = np.aray([np.multiply()])
def estimate_cl(sky_map, lmax, binary_mask=None, beam_fwhm=0.0, pixwin=False): """ Estimates the TT, EE, BB and TE auto/cross power spectrum. The sky map(s) will be masked by the binary mask provided. beam_fwhm input is in arcmins. It is converted internally to radians. If pixwin is True, the spectra is debeamed with the pixel window function. """ if sky_map.ndim == 1: pol = False else: pol = True if binary_mask is not None: sky_map_masked = mu.mask_map(sky_map, binary_mask=binary_mask, pol=pol) f_sky = mu.get_sky_fraction(binary_mask) else: sky_map_masked = sky_map if hp.maptype == 0: f_sky = 1.0 else: f_sky = np.aray([1.0, 1.0, 1.0]) Bl = hp.gauss_beam(fwhm=np.radians(fwhm / 60.0), lmax=lmax, pol=pol) if pixwin: pixel_window = hp.pixwin(hp.get_nside(sky_map), pol) if pol: spectra = hp.anafast(sky_map_masked.filled(), lmax=lmax)[:4] spectra /= f_sky[1] * Bl.T**2 if pixwin: spectra[0] /= pixwin[0]**2 spectra[1:] /= pixwin[1]**2 else: spectra = hp.anafast(sky_map_masked.filled(), lmax=lmax) spectra /= f_sky * Bl**2 if pixwin: spectra /= pixel_window**2 return spectra
def auto_drive(neural, past_influence=0.2, frame_rate=10): """ Function to drive automatically using the image from the camera. """ # Initialise the car components cam = camera.Camera() cam.camera_init() mot = motor.Motor() # Create a variable that represents the previous decision prev_average = np.aray([0, 0, 0, 0]) # Then we enter a loop while True: start_time = time.time() # I/ La caméra prend une photo image = cam.camera.get_image() formatted = image_load.format_single_image(image) # II/ Conversion via le système de détection de lignes modified = image_modification.modify(formatted) # III/ La photo est envoyée au réseau de neurone de convolution label = neural.predict(modified)[0] # IV/ Mise à la moyenne mobile choice = (1 - past_influence) * label + past_influence * prev_average # V/ Les roues s'activent en fonction de la direction déterminée label = image_load.cat_to_label(choice) if label == "F": mot.forward() elif label == "R": mot.right() elif label == "L": mot.left() elif label == "B": mot.backward() # Si le traitement a pris moins de temps que la durée prévue, wait(start_time, 1 / frame_rate)
def np3dT(data): # keep last axis the same """ Make a tuple, list or numpy array at least a 3d numpy array and transposed first 2 axes. Args: :data: | tuple, list, ndarray Returns: :returns: | ndarray with .ndim >= 3 and with first two axes | transposed (axis=3 is kept the same). """ if isinstance( data, np.ndarray ): # assume already atleast_3d when nd.array (user has to ensure input is an array) if (len(data.shape) >= 3): return data.transpose((1, 0, 2)) else: return np.expand_dims(np.atleast_2d(data), axis=0).transpose( (1, 0, 2)) else: return np.expand_dims(np.atleast_2d(np.aray(data)), axis=0).transpose( (1, 0, 2))
from sklearn.preprocessing import MinMaxScaler import numpy weights = numpy.aray([[115.], [140.], [175.]]) # 必须为浮点数,整数后面要加个点 scaler = MinMaxScaler() rescaled_weight = scaler.fit_transform(weights) # fit_transform()这里进行了两步: # fit:找出最大最小值进行公式计算 # transform:把数组中所有值进行缩放
import numpy as np a=np.array([[1.0,2.0],[3.0,4.0]]) print(a) # [[ 1. 2.] # [ 3. 4.]] a.transpose()#没改变a # [[ 1., 3.], # [ 2., 4.]] np.linalg.inv(a)#矩阵的逆 # [[-2. , 1. ], # [ 1.5, -0.5]] u=np.eye(3)#2维的单位矩阵 eye=1 # [[ 1., 0.], # [ 0., 1.]] j=np.array([[0.0,-1.0],[1.0,0.0]]) np.dot(i,j) # ([[-1., 0.], # [ 0., -1.]] np.trace(u)#返回数组对角线的总和。 #2 y=np.aray([[5.],[7.]]) np.linalg.solve(a,y)#线性矩阵方程的解 # [[-3.], # [ 4.]] np.linalg.eig(j)#计算正方形阵列的特征值和特征向量 # array([ 0.+1.j, 0.-1.j]), array([[ 0.70710678+0.j, 0.70710678-0.j], # [ 0.00000000-0.70710678j, 0.00000000+0.70710678j]])
def Uw(): Uw = np.aray([[-1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]) return Uw
import numpy as np import matplotlib.pyplot as plt import essentia.standard as ess M = 1024 N = 1024 H = 512 fs = 44100 spectrum = ess.Spectrum(size=N) window = ess.Windowing(size=M, type='hann') mfcc = ess.MFCC(numberCoefficients=12, inputSize=N / 2 + 1) x = ess.MonoLoader(filename='../sounds/speech-female.wav', sampleRate=fs)() mfccs = [] for frame in ess.FrameGenerator(x, frameSize=M, hopSize=H, startFromZero=True): mX = spectrum(window(frame)) mfcc_bands, mfcc_coeffs = mfcc(mX) mfccs.append(mfcc_coeffs) mfccs = np.aray(mfccs)
def ellipse(x_t, a=[1, 1], p=[1, 1]): Gamma = np.sum((x_t / np.array(a))**(2 * np.aray(p)))
def kmeans_pp(A, k, weighted=True, sparse=False, verbose=False): ''' Returns $k$ initial centers based on the k-means++ initialization scheme. With weighted set to True, we have the standard algorithm. When weighted is set to False, instead of picking points based on the D^2 distribution, we pick the farthest point from the set (careful deterministic version -- affected by outlier points). Note that this is not deterministic. A: nxd data matrix (sparse or dense). k: is the number of clusters. Returns a (k x d) dense matrix. K-means ++ ---------- 1. Choose one center uniformly at random among the data points. 2. For each data point x, compute D(x), the distance between x and the nearest center that has already been chosen. 3. Choose one new data point at random as a new center, using a weighted probability distribution where a point x is chosen with probability proportional to D(x)2. 4. Repeat Steps 2 and 3 until k centers have been chosen. ''' n, d = A.shape if n <= k: if sparse: A = A.toarray() return np.aray(A) index = np.random.choice(n) if sparse is True: B = np.squeeze(A[index].toarray()) assert len(B) == d inits = [B] else: inits = [A[index]] indices = [index] t = [x for x in range(A.shape[0])] distance_matrix = distance_to_set(A, np.array(inits), sparse=sparse) distance_matrix = np.expand_dims(distance_matrix, axis=1) while len(inits) < k: if verbose: print('\rCenter: %3d/%4d' % (len(inits) + 1, k), end='') # Instead of using distance to set we can compute this incrementally. dx = np.min(distance_matrix, axis=1) assert dx.ndim == 1 assert len(dx) == n dx = dx**2 / np.sum(dx**2) if weighted: choice = np.random.choice(t, 1, p=dx)[0] else: choice = np.argmax(dx) if choice in indices: continue if sparse: B = np.squeeze(A[choice].toarray()) assert len(B) == d else: B = A[choice] inits.append(B) indices.append(choice) last_center = np.expand_dims(B, axis=0) assert last_center.ndim == 2 assert last_center.shape[0] == 1 assert last_center.shape[1] == d dx = distance_to_set(A, last_center, sparse=sparse) assert dx.ndim == 1 assert len(dx) == n dx = np.expand_dims(dx, axis=1) a = [distance_matrix, dx] distance_matrix = np.concatenate(a, axis=1) if verbose: print() return np.array(inits)
def __init__(self, parent=None): super(IV_Controller, self).__init__(parent) self.gpib_resource = None self.stop_measurement_early = False self.Voltage_Sweep_Func = lambda self, input_start, input_end, input_step, time_interval: ( np.aray(), np.array())
from scipy import stats from pylab import save from pythonutils.odict import OrderedDict #################################################################################################### # Define opportunities to commit CD and the reward sensitivity #################################################################################################### opprtn = np.linspace(0,1,101) nRwdPnsh = 12 # parameters of the genotype rspnPrmExternalizing = np.vstack(([.3,.9,.2],[.7,.3,.4])) # ,[1,.1,.1] pExt = [k[0]*sp.stats.norm.cdf(opprtn, k[1], k[2]) for k in rspnPrmExternalizing] #sensitivity_to_Pns = [sp.stats.uniform.rvs(-.5, 1, size=nRwdPnsh), sp.stats.uniform.rvs(-.5, 1, size=nRwdPnsh)] sensitivity_to_PnsY = [np.array([1, 1, 1.5, .8, 1, .9, .1, 0, .6, .9, 1.2, 1]), np.aray([.8, .8, .7, 1.4, 1.4 ,.3,.3,.4,.5,.5,.5,.4]) sensitivity_to_PnsX = np.linspace(1,12,12) #rspnPrmResCntrl = np.vstack(([.3,.9,.2],[.5,.3,.4],[1,.1,.1])) #sensitivity_to_Rwrd = np.vstack(([.3,.9,.2],[.5,.3,.4],[1,.1,.1])); # parameters of the social system # pshmnt_Intensity = np.vstack(([.3,.9,.2],[.5,.3,.4],[1,.1,.1])) # rwrd_Intensity = np.vstack(([.3,.9,.2],[.5,.3,.4],[1,.1,.1])) freedom = np.array([.2, .9]) adaptability_pnshX = [np.linspace(1,12,12), np.linspace(1,11,6), np.array([3, 8, 10]) adaptability_pnshY = [np.ones(12)/12, np.array([[.2 .2 .1 .1 .2 .2]), np.array(.8,.1,.1), np.array([3, 8, 10]) resp_coherence = [0, 1] deg_monitor = [.2, .8]
import numpy as np a = np.aray(1, 20) print(a)
def table_to_XY(data): """Converts the Orange.Table data to pairs of input and output vectors (represented row-wise in two numpy.arrays X, Y) suitable to be used as a training/testing set for a Artificial neural network. The attributes are created by the Table.to_numpy method. The class attribute(s) are transformed as follows: - each Continuous class attribute (regression), is assinged one output neuron (no scaling is performed on this step) - each Discrete class attribute (classification), is assinged one output neuron for each discrete value of this class. E.g. in the iris dataset (one discrete class attribute noting the name of the flower), we have 3 neurons. """ if not len(data): return numpy.array(), numpy.aray() ## prepare the training data # classes cls_descriptors = filter( lambda desc: desc, [data.domain.class_var] + list(data.domain.class_vars)) def get_unfolder(descriptor): """Unfolds class variable into a number of output neurons' output """ if isinstance(descriptor, Orange.feature.Continuous): def unfold(value): return [float(value)] elif isinstance(descriptor, Orange.feature.Discrete): def unfold(value): l = [-1.0] * len(descriptor.values) l[int(value)] = 1.0 return l else: raise ValueError("Unsupported class variable type '%s'. Must be either Discrete or Continuous."%descriptor.var_type) return unfold unfolders = map(get_unfolder, cls_descriptors) def get_class_values(instance): l = [] if data.domain.class_var: l = [instance.get_class()] return l + instance.get_classes() y = [] # flatten([[0,0,0,1], [0.44], [1,0]]) = # [ 0, 0, 0, 1, 0.44, 1, 0 ] flatten = lambda it: list(itertools.chain.from_iterable(it)) # multi_map([lambda x: x + 1, lambda x: x * 2], [0, 10]) = # [1, 20] multi_map = lambda Fs, Args : [ f(arg) for f, arg in zip(Fs, Args) ] for instance in data: values = get_class_values(instance) y.append( flatten(multi_map( unfolders, values )) ) # attributes X = data.to_numpy()[0] # classes Y = numpy.array(y) """ print "X" for instance in data: print len(instance) print instance print "Y" print Y """ return X, Y
import numpy as np from sklearn import preprocessing, cross_validation, neighbors import pandas as pd df = pd.read_csv('breast-cancer.txt') df.replace('?', -99999, inplace=True) df.drop(['id'], 1, inplace=True) X = np.array(df.drop(['class'], 1)) y = np.array([df['class']]) X_train, X_test, y_train, y_test = cross_validation.train_test_split( X, y, test_size=0.2) clf = neighbors.KNeighborsClass() clf.fit(X_train, y_train) accuracy = clf.score(X_test, y_test) print(accuracy) example_measures = np.aray([4, 2, 1, 1, 1, 3, 2, 1]) example_measures = example_measures.reshape(1, -1) prediction = clf.predict(example_measures) print(prediction)
def position(self,p): self._position = np.aray(p)
import numpy as np from scipy.stats import norm import matplotlib matplotlib.use('Agg') import matplotlib.pyplot as plt a= np.aray([1,2,3]) print type(a) print a.shape print a[0],a[1],a[2] a[0]=5 print "......." print norm.cdf(0) x=np.arrange(0.3*np.pi,0.1) y=np.sin(x) plt.plot(x,y) plt.savefig("plt_test.png") print "\nDone"