def test(): resnet50.eval() epoch_loss = 0 gt = [] pre = [] with tqdm(total=data_size - n_train, desc=f'evaluating', unit='img') as pbar: for i_batch, batch_data in enumerate(val_loader): img = batch_data['img'].to(device=device) #print(vin.shape) label = batch_data['label'].cpu() gt += label.numpy().tolist() pred = resnet50(img) pred = pred.squeeze().detach().cpu() loss = criterion(pred, label) epoch_loss += loss.item() #print(pred.shape) if len(list(pred.size())) == 1: pre.append(int(argmax(pred, 0))) else: pre += argmax(pred, 1).tolist() pbar.update(img.shape[0]) #print(np.array(gt)) #print(np.array(pre)) ac = float(sum(np.array(gt) == np.array(pre))) / float(len(gt)) print('accuracy on test set is: ', ac) return gt, pre, epoch_loss, ac
def test(): resnet50.eval() pre = [] with tqdm(total=data_size, desc=f'evaluating', unit='img') as pbar: for i_batch, batch_data in enumerate(val_loader): img = batch_data['img'].to(device=device) pred = resnet50(img) pred = pred.squeeze().detach().cpu() if len(list(pred.size())) == 1: pre.append(int(argmax(pred, 0))) else: pre += argmax(pred, 1).tolist() pbar.update(img.shape[0]) return np.array(pre)
def drawline(data): # 画平行线 global dots length = 0 # 画线总长 times = 0 # 平行线数量 for i in range(len(data)): line = np.array([0, 0]) area = data[i] maxy = round(max(area[:, 1]), 1) miny = round(min(area[:, 1]), 1) j = miny while j <= maxy: index = (np.where(area == j))[0] temp = area[index, 0] if round(j / abs(d)) % 2: line = np.row_stack((line, [j, min(temp)])) temp = np.delete(temp, argmin(temp)) line = np.row_stack((line, [j, min(temp)])) else: line = np.row_stack((line, [j, max(temp)])) temp = np.delete(temp, argmax(temp)) line = np.row_stack((line, [j, max(temp)])) j = round(j + abs(d), 1) line = np.delete(line, 0, axis=0) line = np.column_stack((line[:, 1], line[:, 0])) writecsv(line, i) plt.plot(line[:, 0], line[:, 1], '-', color='r') times = times + int(line.shape[0] / 2) for j in range(line.shape[0] - 1): length = length + \ math.sqrt((line[j+1, 0]-line[j, 0])**2 + (line[j+1, 1]-line[j, 1])**2) dots += 1 i += 1 return ([length, times])
def run(self): ages = [(1, 0.1), (1.5, 0.4), (1.7, 0.1), (1.8, 0.2), (2.1, 0.5)] pool = Pool(processes=10) n = 1e5 # st = time.time() # aa = ((ai, ages) for ai in arange(n)) # print 'a"', time.time() - st age_gen = age_generator(ages, n) st = time.time() results = pool.map(_monte_carlo_step, age_gen) print 'a', time.time() - st st = time.time() results = vstack((ri for ri in results if ri is not None)) print 'b', time.time() - st for xx, (ai, ei) in zip(results.T, ages): # print 'dev ', abs(xx.mean() - ai) / ai * 100, abs(xx.std() - ei) / ei * 100 # print xx f, v = histogram(xx, 40) lp = plot(v[:-1], f)[0] c = lp.get_color() nf = smooth(f, window='flat') plot(v[:-1], nf, c=c, ls='--', lw=2) axvline(ai, c=c) # print f, v idx = argmax(nf) # axvline(xx.mean(), c=c, ls='--') axvline(v[idx], c=c, ls='--') show()
def detectCommunityForNode(net,alpha,node,useStrength=True): com=[node] cont=True while cont==True and len(com)>0: neighbors=getNeighborNodes(net,com) if len(neighbors)==0: break fitness=map(lambda x:getNodeFitness(net,com,x,alpha,useStrength),neighbors) best=argmax(fitness) if fitness[best]<0: cont=False else: com.append(neighbors[best]) remove=True while remove==True: remove=False newcom=[] fitness=getNodeFitnessForAll(net,com,alpha,useStrength) for i,n in enumerate(com): #if getNodeFitness(net,com,n,alpha,useStrength)>=0: if fitness[i]>=0: newcom.append(n) else: remove=True com=newcom return com
def monteCarloHeuristic(gs, moves=None, maxDepth=None, verbose=False): """Determines the best move using a Monte-Carlo estimation of the final scores""" if moves==None: moves = gs.legalMoves() nextStates = map(lambda move : gs.clone().playMove(move), moves) relativeScoreGrid = [[] for _ in xrange(len(moves))] for trial in xrange(1000000): for m in xrange(len(moves)): scores = nextStates[m].monteCarloScores(\ gs,maxDepth=maxDepth) if verbose: print "trial %d, move %d/%d, scores : %s" \ % (trial+1, m+1, len(moves), scores) relativeScoreGrid[m].append(scores) # for each move, compute the margin of each winning trial winningMargin = [ map(lambda z : z[1][-1]-z[1][-2], \ ifilter(lambda y: y[0][-1]==gs.nextPlayer, \ izip(imap(argsort,x),x))) \ for x in relativeScoreGrid ] choice = argmax(map(mean,winningMargin)) if verbose: print "best move so far is %d, mean margin = %f (wins %d/%d)" \ % (choice+1, mean(winningMargin[choice]), \ len(winningMargin[choice]), trial+1) yield moves[choice]
def predict_on_patches(val_loader): pre = [] global model global DEVICE # with tqdm(total = len(val_loader), desc = f'evaluating',unit = 'img') as pbar: for i_batch, batch_data in enumerate(val_loader): img = batch_data['img'].to(device=DEVICE) pred = model(img) pred = pred.squeeze().detach().cpu() if len(list(pred.size())) == 1: pre.append(int(argmax(pred, 0))) else: pre += argmax(pred, 1).tolist() # pbar.update(img.shape[0]) return np.array(pre)
def top_docs(x): num_topics = 11 mgp = pickle.load(open(path / ('Models/GSDMMModel.pkl'), 'rb')) top_docs = [{} for _ in range(num_topics)] doc_set = set() ind = -1 for doc in data_words: ind += 1 doc_joined = ' '.join(doc) if doc_joined in doc_set: continue doc_set.add(doc_joined) probabilities = mgp.score(doc) top_docs[argmax(probabilities)][ind] = max(probabilities) for ind in range(len(top_docs)): topic = top_docs[ind] sorted_topic = sorted(topic.items(), key=lambda kv: kv[1], reverse=True) top_docs[ind] = sorted_topic topic_ind = 1 for topic in top_docs: print('Topic %s' % topic_ind) topic_ind += 1 num = 0 for doc in topic: if num >= x: break print(orig_data[doc[0]]) print('-------') num += 1 print('--------------------------------')
def predict(self, X): neighbors = self.kneighbors(X, return_distance=False) predicted = [] for ns in neighbors: votes = [0.0, 0.0] for n in ns: vote = int(self.Y[n]) votes[vote] += self.class_weights[vote] predicted.append(argmax(votes)) return numpy.array(predicted)
def test(): net.eval() pre = [] with torch.no_grad(): probs = t.Tensor(proba_results).to(device=device) print(probs.shape) pred = net(probs) pred = pred.squeeze().detach().cpu() pre += argmax(pred, 1).tolist() return pre
def retrieve_input(texto): if (texto == ""): return "" texto_procesado = str(preprocess(texto)) loaded_tfidf = pickle.load(open("tf-idf_model.sav", 'rb')) transformed_text = loaded_tfidf.transform([texto_procesado]) loaded_model = pickle.load(open("modelo_datos.sav", 'rb')) prediction = loaded_model.predict_proba(transformed_text) lista_ods = [ "Fin de la pobreza", "Hambre cero", "Salud y bienestar", "Educacion de calidad", "Igualdad de genero", "Agua limpia y saneamiento", "Energia asequible y no contaminante", "Trabajo decente y crecimiento economico", "Industria, Innovacion e Infraestructura", "Reduccion de las desigualdades", "Ciudades y comunidades sostenibles", "Produccion y consumo responsables", "Accion por el clima", "Vida submarina", "Vida de ecosistemas terrestres", "Paz, Justicia e Instituciones solidas", "Alianzas para lograr los objetivos" ] print("----- RESULTADOS OBTENIDOS -----") print("") result = argmax(prediction) print( f" El texto ha sido clasificado como ODS {result+1} -> {lista_ods[result]}" ) print("") print("Las probabilidades obtenidas para cada ods son las siguientes:") #cambiar lambda por 0 o 1 para tenerlo ordenado o no lista = sorted(list(enumerate(prediction[0])), key=lambda prediction: prediction[1], reverse=True) for index, val in lista: value = prediction[0][index] print( f" ODS {(index+1):<2} - {value:>8.2%} -> {lista_ods[index]:<40}" )
def run(self): ages = [(1, 0.1), (1.5, 0.4), (1.7, 0.1), (1.8, 0.2), (2.1, 0.5)] pool = Pool(processes=10) n = 1e5 # st = time.time() # aa = ((ai, ages) for ai in arange(n)) # print 'a"', time.time() - st age_gen = age_generator(ages, n) st = time.time() results = pool.map(_monte_carlo_step, age_gen) print 'a', time.time() - st st = time.time() results = vstack((ri for ri in results if ri is not None)) print 'b', time.time() - st for xx, (ai, ei)in zip(results.T, ages): # print 'dev ', abs(xx.mean() - ai) / ai * 100, abs(xx.std() - ei) / ei * 100 # print xx f, v = histogram(xx, 40) lp = plot(v[:-1], f)[0] c = lp.get_color() nf = smooth(f, window='flat') plot(v[:-1], nf, c=c, ls='--', lw=2) axvline(ai, c=c) # print f, v idx = argmax(nf) # axvline(xx.mean(), c=c, ls='--') axvline(v[idx], c=c, ls='--') show()
def net_feature(image, distance_to_center_filter_pixels, n): img = image #Find the center of the image height, width, col = img.shape coordinate = [height / 2, width / 2] y = int(coordinate[0]) x = int(coordinate[1]) #Set up the detector params = cv2.SimpleBlobDetector_Params() params.filterByInertia = False params.filterByConvexity = False params.minThreshold = 50 params.maxThreshold = 255 params.filterByColor = True params.blobColor = 255 params.filterByArea = False params.minArea = 1 detector = cv2.SimpleBlobDetector_create(params) #Detect stars keypoints = detector.detect(img) coord = [] for index, keypoint in enumerate(keypoints): x_centralstar = int(round(keypoints[index].pt[0])) y_centralstar = int(round(keypoints[index].pt[1])) distance_to_center = sqrt(((x_centralstar - x)**2) + ((y_centralstar - y)**2)) coord.append([x_centralstar, y_centralstar, distance_to_center]) # cv2.circle(img,center=(x_centralstar,y_centralstar),radius=2,color=(255,0,0),thickness=2) #Find stars within radius stars_within_radius = [] for coordinate in coord: dist_to_center = coordinate[2] if (dist_to_center < distance_to_center_filter_pixels): stars_within_radius.append(coordinate) if len(stars_within_radius) == 0: return img #Find magnitude of star within radius magnitude_of_star_within_radius = [] for star in stars_within_radius: x = star[0] y = star[1] brightness_value = img[y, x][0] magnitude_of_star_within_radius.append(brightness_value) #Find index of brightest star and coordinate max_index = argmax(magnitude_of_star_within_radius) pivot_coord = stars_within_radius[max_index] cv2.circle(img, center=(pivot_coord[0], pivot_coord[1]), radius=2, color=(255, 0, 0), thickness=2) #Find nearest stars x_pivot = pivot_coord[0] y_pivot = pivot_coord[1] distances = [] for coordinate in coord: x_relate = coordinate[0] y_relate = coordinate[1] delta_x = abs(x_pivot - x_relate) delta_y = abs(y_pivot - y_relate) distance = sqrt((delta_x * delta_x) + (delta_y * delta_y)) if (distance == 0): continue distances.append([distance, coordinate]) distances = sorted(distances, key=lambda row: row[0]) neighbor_stars = [] for distance in distances: neighbor_stars.append(distance[1]) #Draw circle and line for i, star in enumerate(neighbor_stars): cv2.circle(img, center=(star[0], star[1]), radius=2, color=(255, 0, 0), thickness=2) cv2.line(img, (pivot_coord[0], pivot_coord[1]), (star[0], star[1]), (255, 0, 0), 2) if i == n - 1: break return img
from keras.models import load_model from keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img import matplotlib.pyplot as plt import cv2 from numpy.core.fromnumeric import argmax # read own image #image = cv2.imread('pix/mercedes280.jpg', cv2.IMREAD_UNCHANGED) image = cv2.imread('pix/audiropika.jpg', cv2.IMREAD_UNCHANGED) # convert color space image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) # resize image image=cv2.resize(image,(32,32)) # normalize image image = image.astype('float32') image = image / 255.0 # get the compiled model model = load_model('scnn.h5') # add 0st dimenstion (nb_samples) for input of Convolution2D reshaped_image = image.reshape( (1,) + image.shape ) # predict prediction = argmax(model.predict(reshaped_image)) # show image plt.imshow(image) plt.title('This is a '+['car', 'cat'][prediction]) plt.show()
if __name__ == "__main__": #Get user data usersdF = pd.read_csv("data/users.csv", index_col="Name") user_name = input("Name:") user_taste = usersdF.loc[user_name] #Prepare plot fig = plt.figure(figsize=(10,5)) ax = fig.add_subplot(111) #Get best recommendations best_recommendations = [] for i in range(10): mu = np.random.random() pop,log = algorithms.eaMuCommaLambda(pop,toolbox,10,10,mu,1-mu,100,stats = stats,verbose=False) best_recommendations.append(pop[argmax(map(evaluation,pop))]) df = pd.DataFrame(log) data= data.append(df) #Get data for plot data = data.reset_index(drop=True) dfAverages = data.groupby(['gen']).agg({'max': ['mean', 'std']}) data_by_gen = data['gen'].unique() averages = dfAverages['max']['mean'].values desviacion = dfAverages['max']['std'].values #Prepare plot ax.set_title("Evolution of model") ax.set_ylabel("Taste match") ax.set_xlabel("Generation") ax.plot(data_by_gen, averages, color='r')