def classify_snap(img): img = cv2.resize(img, dsize=(300, 300), interpolation=cv2.INTER_CUBIC) img = img.reshape(1, img.shape[0], img.shape[1], img.shape[2]) img = img / 255.0 className = classify.predict(model, img) classLabel["text"] = className
def check(*args): file_path = path.get() result = predict('model/classifier.pkl', 'model/features.pkl', file_path) if result: tkinter.messagebox.showinfo('INFO', message='No threat found') else: tkinter.messagebox.showwarning('WARNING', message='Malware detected!')
def post_file(filename): """Upload a file.""" # headers = request.headers # auth = headers.get("X-Api-Key") # if auth != 'mskib0102': # return jsonify({"message": "ERROR: Unauthorized"}), 401 if "/" in filename: # Return 400 BAD REQUEST abort(400, "no subdirectories directories allowed") fullFileName = os.path.join(UPLOAD_DIRECTORY, filename) with open(fullFileName, "wb") as fp: fp.write(request.data) try: return "Success", classify.predict(fullFileName) except ValueError as e: print("Value error \n {0}".format(e)) except AttributeError as a: print("Value error \n {0}".format(a)) except: print("Unexpected error:", sys.exc_info()[0]) abort(500, "Internal Server Error") # Return 201 CREATED abort(500, "Internal Server Error")
def predict_many(classify_request): tweets = classify_request.tweets predictions = [] for tweet in tweets: prediction = predict(tweet.message) prediction_result = PredictionResult(tweet.id, prediction) predictions.append(prediction_result.get_dict()) return predictions
def main(): audio_filename = input("Please choose an audio file(test/1-10.mp3): ") demo_data = feature_extract(audio_filename) print 'processed data.' model_params = {'pca_n': 10, 'knn_k': 5, 'knn_metric': 'minkowski'} # train_and_test(data, [model_params, 'svc']) model = classify.load_model(model_params) pre = classify.predict(model, demo_data, [model_params, 'svc']) result(pre)
def main(): st.set_option('deprecation.showfileUploaderEncoding', False) st.title("Birds Around Here") uploaded_file = st.file_uploader("Choose an image of a bird...") if uploaded_file is not None: image = np.asarray(Image.open(uploaded_file)) st.image(image, caption='Uploaded Image.', use_column_width=True) st.write("") st.write("Classifying...") label, prob = predict(image) st.write(f"{label}, prob={prob*100}")
def predictor(audio_filename): #audio_filename = filedialog.askopenfilename(initialdir = "/",title = "Select file",filetypes = (("mp3 files","*.mp3"),("all files","*.*"))) #input("Please choose an audio file(test/1-10.mp3): ") print audio_filename demo_data = feature_extract(audio_filename) print 'processed data.' model_params = {'pca_n': 10, 'knn_k': 5, 'knn_metric': 'minkowski'} # train_and_test(data, [model_params, 'svc']) model = classify.load_model(model_params) pre = classify.predict(model, demo_data, [model_params, 'svc']) result(pre) return pre
def profileData(clfFile, X, y, threshold=0.5): y = np.squeeze(y) pred = predict(clfFile, X) positives = pred[y==1] negatives = pred[y==0] true_pos = np.where(positives >= threshold)[0] false_neg = np.where(positives < threshold)[0] true_neg = np.where(negatives < threshold)[0] false_pos = np.where(negatives >= threshold)[0] return true_pos, false_neg, true_neg, false_pos, pred
def handle_data(self, data_object): # parse JSON data client_data = json.loads(data_object) filenames = ['circle0.svg','circle1.svg','circle2.svg','circle3.svg','morphism0.svg','morphism1.svg','morphism2.svg'] labels = [1,1,1,1,-1,-1,-1] nodeclf = clf.trainSVM(filenames,labels,1,1) paths_str = client_data[u'pathdata'].split('\n')[1:] pathlist = [celm.path(cp.parseStroke(path_str)) for path_str in paths_str] hypotheses = sgm.segmentPath(pathlist,train=False) [corr_pathlist,intersect] = sgm.correctPathlist(pathlist) normal = clf.predict(hypotheses,nodeclf) if corr_pathlist!=None: correction = clf.predict(corr_pathlist,nodeclf) else: correction = None [wirelist,dotlist,morphismlist] = cn.findWinner(normal,correction,intersect) tree = sp.loadFile('blank.svg') cn.drawOutput(tree,wirelist,dotlist,morphismlist) try: latex_command = td.create_diagram(dotlist,morphismlist,wirelist) except: pass response_data = json.dumps(latex_command) return response_data
def profileData(clfFile, X, y, threshold=0.5): y = np.squeeze(y) pred = predict(clfFile, X) positives = pred[y == 1] negatives = pred[y == 0] true_pos = np.where(positives >= threshold)[0] false_neg = np.where(positives < threshold)[0] true_neg = np.where(negatives < threshold)[0] false_pos = np.where(negatives >= threshold)[0] return true_pos, false_neg, true_neg, false_pos, pred
def main(): st.title("Luekemia Cell Detector") folder_path = '.\\New folder' filename = file_selector(folder_path=folder_path) st.write('You selected `%s`' % filename[13:]) img_u = cv2.imread(filename) img = cv2.resize(img_u,(400,400)) st.image(img, caption='Uploaded Image', use_column_width=True) if st.button('predict'): st.write("**Processing.....**") label = classify.predict(img) label = label.item() res = abbreviation_dict.get(label) st.markdown(res)
def apply_ML(data, sources): decsion_boundary = 0.159 # prepare data for machine learning print "[*] Preparing data for machine learning." X = prepare_data_for_ML(data, sources) pooledFeatures = convolve_and_pool(X) print "[*] Applying feature scaling." tmp = sio.loadmat("/Users/dew/development/PS1-Real-Bogus/ufldl/sparsefiltering/features/"+\ "SF_maxiter100_L1_3pi_20x20_skew2_signPreserveNorm_6x6_k400_patches_"+\ "stl-10_unlabeled_meansub_20150409_psdb_6x6_pooled5.mat")["pooledFeaturesTrain"] tmp = np.transpose(tmp, (0, 2, 3, 1)) numTrainImages = np.shape(tmp)[3] tmp = np.reshape(tmp, (int((tmp.size)/float(numTrainImages)), \ numTrainImages), order="F") scaler = preprocessing.MinMaxScaler() scaler.fit(tmp.T) # Don't cheat - fit only on training data tmp = None X = np.transpose(pooledFeatures, (0, 2, 3, 1)) numImages = np.shape(X)[3] X = np.reshape(X, (int((pooledFeatures.size)/float(numImages)), \ numImages), order="F") X = scaler.transform(X.T) clfFile = "/Users/dew/development/PS1-Real-Bogus/ufldl/sparsefiltering/classifiers/"+\ "SVM_linear_C1.000000e+00_SF_maxiter100_L1_3pi_20x20_skew2_signPreserveNorm"+\ "_6x6_k400_patches_stl-10_unlabeled_meansub_20150409_psdb_6x6_pooled5.pkl" print "[*] Making predictions." pred = predict(clfFile, X) m = len(np.where(pred > decsion_boundary)[0]) print "[*] %d quality detections passing machine learning threshold (5%% FoM)." % ( m) """ print "[*] Plotting quality detections." dim = np.ceil(np.sqrt(m)) fig = plt.figure() for i, index in enumerate(np.where(pred > decsion_boundary)[0]): ax = fig.add_subplot(dim,dim,i+1) position = (sources['xcentroid'][index],sources['ycentroid'][index]) img = data[position[1]-10:position[1]+10,position[0]-10:position[0]+10] ax.imshow(img, cmap="gray_r", interpolation="nearest", origin="lower") plt.axis("off") plt.show() """ return np.where(pred > decsion_boundary)[0]
def classify(): data = json.loads(request.get_data()) #print(data) if data == None: return 'Got None' else: image = eval(data["image"]) #print(image) prediction = predict(image) result = prediction.split() return jsonify({ 'Assembly': result[0], 'Orientation': result[1], 'Face': result[2] })
def apply_ML(data, sources): decsion_boundary = 0.159 # prepare data for machine learning print "[*] Preparing data for machine learning." X = prepare_data_for_ML(data, sources) pooledFeatures = convolve_and_pool(X) print "[*] Applying feature scaling." tmp = sio.loadmat("/Users/dew/development/PS1-Real-Bogus/ufldl/sparsefiltering/features/"+\ "SF_maxiter100_L1_3pi_20x20_skew2_signPreserveNorm_6x6_k400_patches_"+\ "stl-10_unlabeled_meansub_20150409_psdb_6x6_pooled5.mat")["pooledFeaturesTrain"] tmp = np.transpose(tmp, (0,2,3,1)) numTrainImages = np.shape(tmp)[3] tmp = np.reshape(tmp, (int((tmp.size)/float(numTrainImages)), \ numTrainImages), order="F") scaler = preprocessing.MinMaxScaler() scaler.fit(tmp.T) # Don't cheat - fit only on training data tmp = None X = np.transpose(pooledFeatures, (0,2,3,1)) numImages = np.shape(X)[3] X = np.reshape(X, (int((pooledFeatures.size)/float(numImages)), \ numImages), order="F") X = scaler.transform(X.T) clfFile = "/Users/dew/development/PS1-Real-Bogus/ufldl/sparsefiltering/classifiers/"+\ "SVM_linear_C1.000000e+00_SF_maxiter100_L1_3pi_20x20_skew2_signPreserveNorm"+\ "_6x6_k400_patches_stl-10_unlabeled_meansub_20150409_psdb_6x6_pooled5.pkl" print "[*] Making predictions." pred = predict(clfFile, X) m = len(np.where(pred > decsion_boundary)[0]) print "[*] %d quality detections passing machine learning threshold (5%% FoM)." % (m) """ print "[*] Plotting quality detections." dim = np.ceil(np.sqrt(m)) fig = plt.figure() for i, index in enumerate(np.where(pred > decsion_boundary)[0]): ax = fig.add_subplot(dim,dim,i+1) position = (sources['xcentroid'][index],sources['ycentroid'][index]) img = data[position[1]-10:position[1]+10,position[0]-10:position[0]+10] ax.imshow(img, cmap="gray_r", interpolation="nearest", origin="lower") plt.axis("off") plt.show() """ return np.where(pred > decsion_boundary)[0]
def analyze_user(twitter_handler, reddit_handler): def _remove_time(s): return " ".join(s.split("|")[:-1]) sentences = [] if twitter_handler is not None: try: sentences = sentences + twitterapi.get_user_tweets(twitter_handler) except: print("USER DNE") if reddit_handler is not None: try: sentences = sentences + reddit.get_user_activity(reddit_handler) except: print("USER DNE") y, merged_y = predict(sentences) return merged_y[0][1]
def query_image(path): # TODO: query image path = os.path.join(app.config['UPLOAD_FOLDER'], path) if os.path.isfile(path): # TODO: query # key = "865c2ba" # only for demonstration key = predict(path)[0] if key.startswith("w_"): key = key[2:] if key in label_dict: files = label_dict[key] urls = ["train/" + f for f in files] random.shuffle(urls) return jsonify(urls) else: return "no matched images" # TODO: delete, for frontend test # print(path) # urls = [path,path,path,path] # return jsonify(urls) else: return "file invalid"
def main(): st.title("Dogs/Cats Classification") html_temp = """ <div style="background-color:tomato;padding:15px;" <h1> With Convoultion Neural Networks </h1> </div> """ st.markdown(html_temp, unsafe_allow_html=True) uploaded_file = st.file_uploader("Upload an image...", type=["jpg", "png"]) if uploaded_file is not None: file = uploaded_file.read() file_bytes = np.asarray(bytearray(file), dtype=np.uint8) img_cv2 = cv2.imdecode(np.fromstring(file, np.uint8), 1) img = Image.open(uploaded_file) st.image(img, caption='Uploaded Image.', use_column_width=True) pred = predict(img_cv2) if pred == 1: st.success("Bow Bow, it's a DOG") else: st.success("Meow, it's a CAT") st.balloons()
st.title(" ") st.subheader( 'Upload image of Sunflower,Daisy,Dandelion,Roses ,Sunflowers or Tulips') st.title(" ") st.title(" ") uploaded_file = st.file_uploader(".") if uploaded_file is not None: image = Image.open(uploaded_file) lol = load_img(uploaded_file, target_size=(224, 224)) lol = img_to_array(lol) lol = lol / 225.0 lol = np.array([lol]) st.image(image, use_column_width=True) st.write("") if st.button('predict'): final_prediction = classify.predict(lol) st.success( f'The flower in the picture is most likely {final_prediction} ')
st.write(""" # Simple VGG16 Model Classifier """) import streamlit as st import os def file_selector(folder_path='./images'): filenames = os.listdir(folder_path) selected_filename = st.selectbox('Select your Image', filenames) return os.path.join(folder_path, selected_filename) filename = file_selector() st.write('You selected `%s`' % filename) # upload_img = st.file_uploader(label='Upload your Image', type=['png', 'jpg']) if filename: img = Image.open(filename) st.image(img, caption="Your Image", use_column_width=True) st.write("Classifying...") label = predict(filename) st.write('The image is %s with %.2f%% probabiity' % (label[1], label[2]*100)) # if upload_img is not None: # file_bytes = np.asarray(bytearray(upload_img.read()), dtype=np.uint8) # opencv_image = cv2.imdecode(file_bytes, 1)
st.write("") classes = { 0: 'Normal Chest Xray', 1: 'Pneumonia Detected' } st.title("Pneumonia Detection - Machine Learning") st.write("") st.write("") st.subheader("By Jeevan Thukrul") uploaded_file = st.file_uploader("Choose an image...", type=["jpg","png","jpeg"]) if uploaded_file is not None: image = Image.open(uploaded_file) st.image(image, caption='Uploaded Image', use_column_width=True) if st.button('predict'): st.write("Result...") label = classify.predict(uploaded_file) label = label.item() res = classes.get(label) st.success(res) img1 = "Output/cnn_acc.png" img2 = "Output/cnn_loss.png" st.image(img1) st.image(img2)
import cv2 import sys import os import glob import classify as alexnet pathname = sys.argv[1] top_dirs = glob.glob(pathname + "*/") for top_dir in top_dirs: imgs = glob.glob(top_dir + "*.jpg") dirs = glob.glob(top_dir + "*/") f1 = open(top_dir + 'classification.txt', 'w') #classify each image for im_file in imgs: alexnet.predict(im_file, f1, "jpg") f1.close() #run through each dir for a_dir in dirs: distorted_imgs = glob.glob(a_dir + "*.png") f2 = open(a_dir + 'classification.txt', 'w') #classify each image for dist_file in distorted_imgs: alexnet.predict(dist_file, f2, "png") f2.close()
import streamlit as st from PIL import Image from classify import predict st.title("Hotdog Classifier") file = st.file_uploader("Upload an image...", type=["png", "jpg"]) if file is not None: image = Image.open(file) st.image(image, caption="Uploaded image", use_column_width=True) st.write("") st.write("Evaluating...") label = predict(file) if label[1] == "hotdog": st.write("✅ Hotdog") else: st.write("❌ Not hotdog")
def converter(value): if value == 0: return "infected" else: return "uninfected" st.title("Upload + MALARIA IMAGE") st.text("NAME : OMONIYI TEMIDAYO ANDREW") st.text("TEAM : TEAM WAKANDA") st.text("EMAIL: [email protected], [email protected]") st.text("NO: +2348166220117") html_temp=""" <div style="background-color:gray;padding:15px;"> <h2>RGB IMAGE OF BLOOD SAMPLE</h2> </div> """ st.markdown(html_temp,unsafe_allow_html=True) uploaded_file = st.file_uploader("Choose an image...", type=("jpeg","jpg","png")) if uploaded_file is not None: image = Image.open(uploaded_file) st.image(image, caption='Uploaded Image.', use_column_width=True) st.write("") st.write("Classifying...") converter = predict(uploaded_file) st.write('I THINK:', converter)
def predict_demo(bucket_name, slice_id): opt = parse_opts() opt.reload_path = os.path.join(opt.root_path, opt.reload_path) opt.save_path = os.path.join(opt.root_path, opt.data_path) #download dcm files form S3 download_dcm(bucket_name, slice_id, opt.save_path) #TODO:此处提取npy, mask,info 可以改写成多线程.因为数据提取非常耗时 #preprocess dcm files dcm_file = os.path.join(opt.save_path, bucket_name) image, data, mask, info = get_patient_ct_data_mask_info_mhd(dcm_file, opt) '''#########################################################################''' # reload trained deeplab model used to make segment results# '''#########################################################################''' seg_beg_time = time.time() seg_reload_file = os.path.join(opt.reload_path, opt.seg_reload_model) seg_model, _ = model.generate_model(opt, phase='segment') checkpoint = torch.load(seg_reload_file) state_dict = checkpoint['state_dict'] if not opt.no_cuda: #使用GPU seg_model.load_state_dict(state_dict) else: #使用CPU: new_state_dict = OrderedDict() for k, v in state_dict.items(): name = k[7:] # remove `module.` new_state_dict[name] = v seg_model.load_state_dict(new_state_dict) print('reload segment model cost time:', time.time() - seg_beg_time) seg_loader = get_seg_inputs(data, opt) print('get segment data cost time:', time.time() - seg_beg_time) seg_preds = segment.predict(seg_loader, seg_model, opt) seg_results = get_seg_outputs(seg_preds, mask, opt.seg_pred_thresh) print('segment cost time:', time.time() - seg_beg_time) '''#########################################################################''' # reload trained resnet model used to make classify results# '''#########################################################################''' cla_beg_time = time.time() cla_reload_file = os.path.join(opt.reload_path, opt.cla_reload_model) cla_model, _ = model.generate_model(opt, phase='classify') # 'loading checkpoint checkpoint = torch.load(cla_reload_file) state_dict = checkpoint['state_dict'] if not opt.no_cuda: #使用GPU cla_model.load_state_dict(state_dict) else: #使用CPU: new_state_dict = OrderedDict() for k, v in state_dict.items(): name = k[7:] # remove `module.` new_state_dict[name] = v cla_model.load_state_dict(new_state_dict) print('reload classify model cost time:', time.time() - cla_beg_time) cla_loader = sigthread_get_cla_inputs(data, seg_results, opt) print('get classify data cost time:', time.time() - cla_beg_time) cla_prob, cla_pred = classify.predict(cla_loader, cla_model, opt) print('classify cost time:', time.time() - cla_beg_time) ID = dcm_file.split('/')[-1] results = get_cla_outpus(cla_prob, cla_pred, seg_results, info, ID) results.to_csv('results.csv', index=False) print('predict cost all time:', time.time() - load_data_beg_time) show_predict_results(image, results, opt.save_path)
st.write( "This is a simple image classification web app to predict wheather a person is suffering from covid-19 or not" ) file = st.file_uploader("Please upload an image file", type=["jpg", "png", "jpeg"]) buffer = file temp_file = NamedTemporaryFile(delete=False) if buffer: temp_file.write(buffer.getvalue()) st.write(image.load_img(temp_file.name)) if file is None: st.text("You haven't uploaded an image file") else: image = Image.open(temp_file) st.image(image, caption='Uploaded Image', use_column_width=True) st.write("") if st.button('predict'): st.write("Result...") label = classify.predict(temp_file) if label >= 0.5: st.write( "congrats!!! scan shows it's COVID-19 Negative... \n Stay safe" ) else: st.write("Sorry scans shows it's COVID-19")
import streamlit as st from PIL import Image from classify import predict st.title("Upload + Classification Example") uploaded_file = st.file_uploader("Choose an image...", type="jpg") if uploaded_file is not None: image = Image.open(uploaded_file) st.image(image, caption='Uploaded Image.', use_column_width=True) st.write("") st.write("Classifying...") label = predict(uploaded_file) st.write(label) st.write(label[:, 0]) #st.write('%s (%.2f%%)' % (label[0], label[0]*100))
import cluster import itertools INPUT_FILE = "input.log" FEATURES_FILE = "features.csv" RESULT_FILE = "clusterResult.csv" EXTRACTED_SECTIONS_FILE = "detectedSections.log" LABEL_COLUMN_NAME = "label" LINE_NUMBER_COLUMN_NAME = "line_number" features.extractFeatures(inputFile=INPUT_FILE, outputFile=FEATURES_FILE) unlabelledSet = pandas.read_csv(FEATURES_FILE, skipinitialspace=True, header=0) unlabelledSet[LABEL_COLUMN_NAME] = pandas.DataFrame( classify.predict(unlabelledSet), columns=[LABEL_COLUMN_NAME]) #unlabelledSet[LABEL_COLUMN_NAME] = pandas.read_csv("labels.csv", skipinitialspace=True, header=0) labelledSet = unlabelledSet #classify.train(labelledSet, 1000) #classify.evaluate(labelledSet, 1) type10 = cluster.kMeans(10, labelledSet, columnPrefix="type") type100 = cluster.kMeans(100, labelledSet, columnPrefix="type") type1000 = cluster.kMeans(1000, labelledSet, columnPrefix="type") offsetValue = 10
import os import sys import cv2 import imutils import numpy as np import matplotlib.pyplot as plt import pickle from classify import predict folder = sys.argv[1] ####################################################3 pieces = [] # from H8 = pieces[0] to A1 = pieces[63] path = f'C:\\Users\\Jerry\\sys\\{folder}' listing = os.listdir(path) for file in listing: filepath = f'C:\\Users\\Jerry\\sys\\{folder}\\{file}' pieces.append(predict(filepath)) squares = [ 'A1', 'B1', 'C1', 'D1', 'E1', 'F1', 'G1', 'H1', 'A2', 'B2', 'C2', 'D2', 'E2', 'F2', 'G2', 'H2', 'A3', 'B3', 'C3', 'D3', 'E3', 'F3', 'G3', 'H3', 'A4', 'B4', 'C4', 'D4', 'E4', 'F4', 'G4', 'H4', 'A5', 'B5', 'C5', 'D5', 'E5', 'F5', 'G5', 'H5', 'A6', 'B6', 'C6', 'D6', 'E6', 'F6', 'G6', 'H6', 'A7', 'B7', 'C7', 'D7', 'E7', 'F7', 'G7', 'H7', 'A8', 'B8', 'C8', 'D8', 'E8', 'F8', 'G8', 'H8' ] i = 0 final_out = [] for piece in reversed(pieces): #A1 to H8 final_out.append((squares[i], piece)) i += 1 for i in range(len(final_out)): print(final_out[i], " ")
def main(svg_path, model, mapping): #parser = argparse.ArgumentParser() #args = parser.parse_args() doc = minidom.parse(svg_path + os.sep + 'output.svg') # parseString also exists path_strings = [ path.getAttribute('d') for path in doc.getElementsByTagName('path') ] height = float([ path.getAttribute('height') for path in doc.getElementsByTagName('svg') ][0]) width = float([ path.getAttribute('width') for path in doc.getElementsByTagName('svg') ][0]) scale_raw = [ path.getAttribute('transform') for path in doc.getElementsByTagName('g') ] scale = 1 try: for maybe in scale_raw: if 'scale' in maybe: scale = float(re.sub(r's.*,', '', maybe).replace(')', '')) height /= scale break except: print("No scale present") def dist_f(x, y): return np.sqrt(np.sum((x - y)**2)) points = None ends = [] groups = None for path in path_strings: path_parse = parse_path(path) length = path_parse.length(error=1e-5) if length < (max(width / 500, 20)): continue num_points = 200 point_arr = np.asarray([[ int(round(path_parse.point(x).real)), int(round(path_parse.point(x).imag)) ] for x in np.linspace(0, 1, num_points)], dtype=np.float32) print(point_arr.min(axis=0), point_arr.max(axis=0)) if points == None: points = [{'points': point_arr, 'path': [path]}] # combining in loop grouped = False # for n, p in enumerate(points): # pts = p['points'] # dist_arr = distance.cdist(pts, point_arr, 'euclidean') # dist = dist_arr.min() # if dist < width / 15: # print("Combined") # if groups is None: # groups = [{'points': point_arr, 'paths': [path]}] # else: # for g in groups: # if p['path'] in g['paths']: # grouped = True # arr_1 = g['points'] # g['points'] = np.concatenate((g['points'], point_arr)) # g['paths'].append(path) # break if grouped == False: if groups is None: groups = [{'points': point_arr, 'paths': [path]}] groups.append({'points': point_arr, 'paths': [path]}) points.append({'points': point_arr, 'path': path}) print("Combined groups ", len(groups)) gl = 0 for i in groups: gl += len(i['paths']) print(gl, len(path_strings)) groups = combineGroups(groups, width, 200) words = combineWords(groups, width, 15) fixWordOrder(words) fixLetters(words) boxes = [] image = cv2.imread(svg_path + os.sep + "extract.jpg") height = int(height * scale * 0.8) width = int(width * 0.8) print(len(groups)) # formBoundaries(groups, image, scale, width, height) # formBoundaries(words, image, scale, width, height) gl = 0 for i in words: gl += len(i['letters']) print(gl) print(len(words)) image2 = copy.deepcopy(image) word_letters = [] for ind, w in enumerate(words): tmp_folder = svg_path + "word-" + str(ind) + os.sep word_letters.append({'path': tmp_folder, 'len': len(w['letters'])}) if not os.path.exists(tmp_folder): os.makedirs(tmp_folder) formBoundaries(w['letters'], image, scale, width, height, tmp_folder, image2) cv2.imwrite(svg_path + "line_detect.jpg", image2) print(word_letters) words = [] for ww in word_letters: word = '' for l in range(ww['len']): char_path = ww['path'] + str(l) + ".jpg" prediction = classify.predict(char_path, model, mapping) word += prediction words.append(word) f = open(svg_path + 'prediction.txt', 'w') sentence = (" ").join(words) f.write(sentence) f.close() return sentence
def predict_demo(): beg_time = time.time() opt = parse_opts() opt.reload_path = os.path.join(opt.root_path, opt.reload_path) #opt.image_path = os.path.join(opt.root_path,opt.image_path) #opt.mask_path = os.path.join(opt.root_path,opt.mask_path) opt.image_path = os.path.join(opt.root_path, '../../datas/test_data/' + opt.image_path) opt.mask_path = os.path.join(opt.root_path, '../../datas/test_data/' + opt.mask_path) '''#########################################################################''' # ----------reload pretrained models-------------# '''#########################################################################''' beg_time = time.time() # segment checkpoint seg_reload_file = os.path.join(opt.reload_path, opt.seg_reload_model) seg_model, _ = model.generate_model(opt, phase='segment') seg_checkpoint = torch.load(seg_reload_file) seg_state_dict = seg_checkpoint['state_dict'] if not opt.no_cuda: #使用GPU seg_model.load_state_dict(seg_state_dict) else: #使用CPU: new_seg_state_dict = OrderedDict() for k, v in seg_state_dict.items(): name = k[7:] # remove `module.` new_seg_state_dict[name] = v seg_model.load_state_dict(new_seg_state_dict) # loading classify checkpoint cla_reload_file = os.path.join(opt.reload_path, opt.cla_reload_model) cla_model, _ = model.generate_model(opt, phase='classify') cla_checkpoint = torch.load(cla_reload_file) cla_state_dict = cla_checkpoint['state_dict'] if not opt.no_cuda: #使用GPU cla_model.load_state_dict(cla_state_dict) else: #使用CPU: cla_new_state_dict = OrderedDict() for k, v in cla_state_dict.items(): name = k[7:] # remove `module.` new_cla_state_dict[name] = v cla_model.load_state_dict(new_cla_state_dict) print('load model cost time:', time.time() - beg_time) # loop evalutation datas results = pd.DataFrame() names = os.listdir(opt.image_path) for i, name in enumerate(names): predict_beg_time = time.time() # load data image_path = os.path.join(opt.image_path, name) mask_path = os.path.join(opt.mask_path, name) state = get_patient_image_mask(image_path, mask_path, opt.seg_sample_size) if state == None: print('file have error shape') continue else: image, mask = state # seg seg_loader = get_seg_inputs(image, opt) seg_pred = segment.predict(seg_loader, seg_model, opt) seg_result, _ = get_seg_outputs(seg_pred, mask, opt.seg_pred_thresh) # cla cla_loader = get_cla_inputs(image, seg_result, opt) cla_prob, cla_pred = classify.predict(cla_loader, cla_model, opt) cla_result = get_cla_outpus(cla_prob, cla_pred, seg_result) # combin result ID = name.split('.')[0] cla_result['ID'] = ID results = results.append(cla_result) print('loop %d: predict %s cost time:' % (i, name), time.time() - predict_beg_time) targets = pd.read_csv(os.path.join( opt.root_path, '../../datas/origin_datas/csv/annotations_detail.csv'), dtype={'ID': str}) results.to_csv('outputs.csv', index=False) statistics(results, targets) print('predict all file cost time:', time.time() - beg_time)
import streamlit as st from PIL import Image from classify import predict st.title("Image Classifier ML Web") selected_model = st.sidebar.selectbox('모델 선택', ('xception', 'vgg16')) uploaded_file = st.file_uploader('이미지 업로드', type=("png", "jpg")) if uploaded_file is not None: image = Image.open(uploaded_file) st.image(image, caption='업로드된 이미지', use_column_width=True) st.write("") st.write("분류중...") label = predict(uploaded_file, selected_model) st.success('%s (%.2f%%)' % (label[1], label[2] * 100))
def plot_MDR_vs_mag(clfFile, X, fileList, infoFile, threshold=0.5, color="#FF0066"): pred = predict(clfFile, X) mags = [] for line in open(infoFile,"r").readlines(): #print line.rstrip().split(",")[-1].split("/")[-1] in set(fileList) if line.rstrip().split(",")[-1].split("/")[-1] in set(fileList): #print float(line.rstrip().split(",")[4]) mags.append(float(line.rstrip().split(",")[4])) font = {"size" : 20} plt.rc("font", **font) plt.rc("legend", fontsize=18) bins = np.arange(14,23,1) n, bins, patches = plt.hist(mags, bins=bins) #print bins bin_allocations = np.digitize(mags, bins) #print bin_allocations MDRs = [] for i in range(1,len(bins)): if n[i-1] == 0: MDRs.append(0) continue preds_for_bin = pred[np.squeeze(np.where(bin_allocations == i))] MDRs.append(np.shape(np.where(preds_for_bin >= threshold))[1] / float(n[i-1])) print MDRs mid_points = [] for i in range(len(bins)-1): mid_points.append(np.mean([bins[i], bins[i+1]])) fig = plt.figure() ax2 = fig.add_subplot(111) bins = np.arange(14,23,1) ax1 = ax2.twinx() ax2.set_xlabel("Magnitude") ax1.set_ylabel("Frequency") ax1.set_ylim(ymin=0-0.01*np.max(n), ymax=np.max(n)+0.01*np.max(n)) n, bins, patches = ax1.hist(mags, bins=bins, color=color, \ alpha=0.25, edgecolor="none")#FF0066 ax2.set_zorder(ax1.get_zorder()+1) ax2.patch.set_visible(False) ax2.set_ylim(ymin=-0.01, ymax=1.01) #print np.shape(MDRs) #print np.shape(mid_points) #oldMDRs = [1.0, 0.5555555555555556, 0.6666666666666666, 1.0, 0.6666666666666666, \ # 0.6097560975609756, 0.2923076923076923, 0.06217616580310881, 0.05673758865248227, \ # 0.06451612903225806, 0.1794871794871795] #ax2.plot(mid_points, oldMDRs, "-",label="old", color = "#66FF33", lw=2, alpha=0.5) #ax2.plot(mid_points, oldMDRs, ".", color = "#66FF33", ms=10, markeredgecolor='none', alpha=0.5) ax2.plot(mid_points, MDRs, "-",color = "k", lw=3) ax2.plot(mid_points, MDRs, "-",label="new", color = color, lw=2) ax2.plot(mid_points, MDRs, "o", color = color, ms=5)#3366FF ax2.plot(mid_points+[12,18,25], 0.211*np.ones(np.shape(mid_points+[12, 18, 25])), "--", color="k", lw=2) ax2.set_ylabel("Missed Detection Rate") ax2.set_xlim(xmin=13.9, xmax=22.1) ax2.grid() ax2.text(14.1,0.215,"0.211", size=18, color="k") #ax2.legend() plt.show()