def prediction(net): # Draw or clear? option = st.radio('Select option: ', ('Draw', 'Clear')) if (option == 'Draw'): st.write("Draw a digit below and click on Predict button.") else: st.write( "Double click on the digit or refresh the page to clear the digit." ) # Create a canvas component image_data = st_canvas(15, '#FFF', '#000', height=280, width=280, drawing_mode=(option == 'Draw'), key="canvas") # Predicting the image if image_data is not None: if st.button('Predict'): # Model inference digit, confidence = predictDigit(image_data, net) st.write('Recognized Digit: {}'.format(digit)) st.write('Confidence: {:.2f}'.format(confidence))
def prediction(net): # Draw or clear? #drawing_mode = st.checkbox("Draw or clear?",True) drawing_mode = "freedraw" # Create a canvas component #image_data = st_canvas( # 15, '#FFF', '#000', height=280,width=280, drawing_mode=drawing_mode, key="canvas" #) canvas_result = st_canvas(stroke_width=15, stroke_color='#FFF', background_color='#000', height=280, width=280, drawing_mode=drawing_mode, key="canvas") # Predicting the image if canvas_result.image_data is not None: if st.button('Predict'): # Model inference image = canvas_result.image_data #print("[INFO] image shape = ",image.shape) digit, confidence = predictDigit(image, net) print('[INFO]', ' Recognized Digit: {}'.format(digit), ' Confidence: {:.2f}'.format(confidence)) st.write('Recognized Digit: {}'.format(digit)) st.write('Confidence: {:.2f}'.format(confidence))
def run(): # TITLE & INITIAL TEXT st.title("Operations Planning") st.set_option("deprecation.showfileUploaderEncoding", False) st.markdown( """ Draw surface operations on the canvas, and view diagrams below! * Doubleclick to remove the selected object when not in drawing mode """ ) # DRAWING TOOLS st.sidebar.header("Draw") drawing_mode = st.sidebar.selectbox( "Drawing tool:", ("freedraw", "line", "rect", "circle", "transform") ) stroke_width = st.sidebar.slider("Stroke width: ", 1, 25, 3) stroke_color = st.sidebar.beta_color_picker("Stroke color hex: ") # BACKGROUND IMAGES st.sidebar.header("Background Maps") op = st.sidebar.slider('Opacity', 100, (0), key = 'Layer 1') bgImageName = st.sidebar.selectbox("Select from local lunar maps", imageNames) bgImage = copy.copy(images[bgImageName]) bgImage.putalpha(int(256*(op/100))) #bgImage = st.sidebar.file_uploader("Add background image:", type=["png", "jpg"]) #realtimeUpdate = st.sidebar.checkbox("Update in realtime", True) # Create a canvas component canvas_result = st_canvas( fill_color="rgba(255, 165, 0, 0.3)", # Fixed fill color with some opacity stroke_width=stroke_width, stroke_color=stroke_color, background_image= bgImage, #update_streamlit=realtimeUpdate, height=840, width=1120, drawing_mode=drawing_mode, key="canvas", ) col1, col2 = st.beta_columns(2) col1 = canvas_result # Display stand alone diagrmas st.header('Diagram View') st.write('Your standalone diagram will appear in the space below.') # Do something interesting with the image data and paths if canvas_result.image_data is not None: st.image(canvas_result.image_data)
def main(): page_bg_img = ''' <style> body { background-image: url("https://i.pinimg.com/originals/85/6f/31/856f31d9f475501c7552c97dbe727319.jpg"); background-size: cover; } </style> ''' st.markdown(page_bg_img, unsafe_allow_html=True) download_model() ################ load logo from web ######################### # st.markdown('<style>body{color: White; background-color: DarkSlateGrey}</style>', unsafe_allow_html=True) st.title('Riconoscitore di numero') st.markdown(''' Disegna un numero! ''') # data = np.random.rand(28,28) # img = cv2.resize(data, (256, 256), interpolation=cv2.INTER_NEAREST) SIZE = 192 mode = st.checkbox("Draw (or Delete)?", True) canvas_result = st_canvas(fill_color='#000000', stroke_width=20, stroke_color='#FFFFFF', background_color='#000000', width=SIZE, height=SIZE, drawing_mode="freedraw" if mode else "transform", key='canvas') if canvas_result.image_data is not None: img = cv2.resize(canvas_result.image_data.astype('uint8'), (28, 28)) rescaled = cv2.resize(img, (SIZE, SIZE), interpolation=cv2.INTER_NEAREST) st.write('Model Input') st.image(rescaled) if st.button('Predict'): session = onnxruntime.InferenceSession("mnist.onnx") test_x = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) test_x.resize((1, 28, 28, 1)) data = json.dumps({'data': test_x.tolist()}) data = np.array(json.loads(data)['data']).astype('float32') input_name = session.get_inputs()[0].name output_name = session.get_outputs()[0].name result = session.run([output_name], {input_name: data}) prediction = int(np.argmax(np.array(result).squeeze(), axis=0)) st.write(f'result: {prediction}') st.bar_chart(np.array(result).squeeze())
def prediction(net): # Draw or clear? drawing_mode = st.checkbox("Draw or clear?",True) # Create a canvas component image_data = st_canvas( 15, '#FFF', '#000', height=280,width=280, drawing_mode=drawing_mode, key="canvas" ) # Predicting the image if image_data is not None: if st.button('Predict'): # Model inference digit, confidence = predictDigit(image_data,net) st.write('Recognized Digit: {}'.format(digit)) st.write('Confidence: {:.2f}'.format(confidence))
def main(): page_bg_img = ''' <style> body { background-image: url("https://i.pinimg.com/originals/85/6f/31/856f31d9f475501c7552c97dbe727319.jpg"); background-size: cover; } </style> ''' st.markdown(page_bg_img, unsafe_allow_html=True) download_model() ################ load logo from web ######################### model = load_model('mnist.h5') # st.markdown('<style>body{color: White; background-color: DarkSlateGrey}</style>', unsafe_allow_html=True) st.title('My Digit Recognizer') st.markdown(''' Try to write a digit! ''') # data = np.random.rand(28,28) # img = cv2.resize(data, (256, 256), interpolation=cv2.INTER_NEAREST) SIZE = 192 mode = st.checkbox("Draw (or Delete)?", True) canvas_result = st_canvas( fill_color='#000000', stroke_width=20, stroke_color='#FFFFFF', background_color='#000000', width=SIZE, height=SIZE, drawing_mode="freedraw" if mode else "transform", key='canvas') if canvas_result.image_data is not None: img = cv2.resize(canvas_result.image_data.astype('uint8'), (28, 28)) rescaled = cv2.resize(img, (SIZE, SIZE), interpolation=cv2.INTER_NEAREST) st.write('Model Input') st.image(rescaled) if st.button('Predict'): test_x = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) val = model.predict(test_x.reshape(1, 28, 28)) st.write(f'result: {np.argmax(val[0])}') st.bar_chart(val[0])
def run(): st.title("Write a number") canvas_result = st_canvas( stroke_width=25, stroke_color="#fff", background_color="#000", height=280, width=280, drawing_mode="freedraw", key="canvas", ) if st.button("Predict"): if canvas_result.image_data[:, :, :3].sum() > 0: output = number_prediction(canvas_result.image_data[:, :, 0]) st.success(f'The output is {output}') else: st.error("Please draw a number")
def input_description(label): """Create Menu for user input includes 'Write' - Custom text message 'Draw' - Sketch field by Streamlit Component 'Upload Image' - Insert a png, jpg, or jpeg image that is displayed """ input_methods = ["Write","Draw","Upload image"] input_options = [] #Load Images for input_description function @st.cache def load_image(image_file): """Display images using Pillow that have been added via the streamlit file_uploader using the input_description function""" img = Image.open(image_file) return img with st.beta_expander(label): input_methods_cols = st.beta_columns(3) for ind,inputs in enumerate(input_methods): input_options.append(input_methods_cols[ind].checkbox(inputs)) if input_options[0]: st.text_area("Write a description:",key="write_area") if input_options[1]: #Provide drawing canvas draw_cols = st.beta_columns(2) stroke_width = draw_cols[0].number_input("Stroke width: ", 1, 6, 3) stroke_color = draw_cols[1].color_picker("Stroke color: ") canvas_result = st_canvas( fill_color="rgba(255, 165, 0, 0.3)", # Fixed fill color with some opacity stroke_width=stroke_width, stroke_color=stroke_color, update_streamlit=False, height=300, drawing_mode="freedraw", key="canvas") if input_options[2]: st.subheader("Custom image:") image_file = st.file_uploader("Upload Images", type=["png","jpg","jpeg"]) if image_file is not None: st.image(load_image(image_file),use_column_width=True)
def main(): layout.footer() st.title("MNIST Number Prediction") left_column, right_column = st.beta_columns(2) PATH = "./mnist_cnn.pt" model = Net() # model = torch.load(PATH) model.load_state_dict(torch.load(PATH)) # model.eval() # st.write(model.eval()) # Create a canvas component with left_column: st.header("Draw a number") st.subheader("[0-9]") canvas_result = st_canvas( fill_color="rgb(0, 0, 0)", # Fixed fill color with some opacity # stroke_width="1, 25, 3", stroke_width = 10, stroke_color="#FFFFFF", background_color="#000000", update_streamlit=True, width=224, height=224, drawing_mode="freedraw", key="canvas", ) # Do something interesting with the image data and paths if canvas_result.image_data is not None: img = canvas_result.image_data grey = rgb2gray(img) grey = zoom(grey, 0.125) x_np = torch.from_numpy(grey).unsqueeze(0) # x = x_np.unsqueeze(0) x = x.float() output = model(x) pred = torch.max(output, 1) pred = pred[1].numpy() with right_column: st.header("Predicted Result") st.title(str(pred[0]))
def get_xy_from_canvas(stroke_color: str, action: str, for_regression: bool): col1, col2 = st.beta_columns([2, 1]) with col1: canvas = st_canvas( stroke_width=10, stroke_color=stroke_color, update_streamlit=True, background_image=get_background(), drawing_mode='circle' if 'add' in action.lower() else 'transform', width=WIDTH, height=HEIGHT, key='canvas') points = [p for p in canvas.json_data['objects'] if p['type'] == 'circle'] x_train = [2 * p['left'] / WIDTH - 1 for p in points] y_train = [1 - 2 * p['top'] / HEIGHT for p in points] if not for_regression: x_train = [[x, y] for x, y in zip(x_train, y_train)] y_train = [int(p['stroke'] == 'yellow') for p in points] with col2: st.dataframe(dict( **({'x1': [x[0] for x in x_train], 'x2': [x[1] for x in x_train]} if not for_regression else {'x': x_train}), **{'y': y_train})) return x_train, y_train
def prediction(net): # Draw or clear? drawing_mode = 'freedraw' if st.checkbox("Draw or clear?", True) else 'transform' # Create a canvas component result = st_canvas(stroke_width=15, stroke_color='#FFF', background_color='#000', height=280, width=280, drawing_mode=drawing_mode, key="canvas") # Predicting the image if result.image_data is not None: if st.button('Predict'): # Model inference digit, confidence = predictDigit(result.image_data, net) st.write('Recognized Digit: {}'.format(digit)) st.write('Confidence: {:.2f}'.format(confidence))
def draw(): b_width = st.sidebar.slider('Brush Width: ', 1, 50, 10) realtime = st.sidebar.checkbox('Update in realtime', True) image_data = st_canvas( brush_width=b_width, brush_color='#FFF', background_color='#000', height=280, width=280, drawing_mode=True, key="canvas" ) try: arr = np.array(image_data, dtype=np.uint8) img = Image.fromarray(arr) img = img.convert('L') img = img.resize((28, 28)) img.save('test.jpg') arr, ans = pred.prediction() return ans except: pass
firebase = pyrebase.initialize_app(config) storage = firebase.storage() st.markdown("## **Enter Medicine Names & Dosage Per Day** :page_with_curl:") st.text('(Optional Section)') st.text('Please wait a few seconds for page to load.') patient_name = st.selectbox('Select Patient:',['user1','user2','user3']) medicines = st.text_area("","Medicine1 - A Days") appointment = st.date_input('Next Appointment Date') with st.spinner('Loading Components...'): st.subheader('Your signature goes here... :black_nib:') sign = st_canvas(fill_color="rgba(255, 165, 0, 0.3)", stroke_width=3,stroke_color='#008FFF',background_color="#FFFF99", height=150,drawing_mode='freedraw',key="canvas") sig = sign.image_data sig = sig[:,:,:3] sig = np.uint8(sig) sig = Image.fromarray(sig) #sig = np.float32(sig) final_sig = sig.resize((150,40), Image.ANTIALIAS) final_sig2 = np.array(final_sig) #st.text(final_sig.shape) #st.text(np.squeeze(sign.image_data).shape) img = Image.new('RGB', (500, 300), color = (73, 109, 137)) d = ImageDraw.Draw(img) text = f"""{medicines}""" font= ImageFont.truetype("patient_images/arial.ttf",15)
image = PitchImage(pitch, image_bytes=image_to_open) st.title('Pitch lines') lines_expander = st.beta_expander('Draw pitch lines on selected image (2 horizontal lines, then 2 vertical lines)', expanded=True) with lines_expander: col1, col2, col_, col3 = st.beta_columns([2,1,0.5,1]) with col1: canvas_image = st_canvas( fill_color = "rgba(255, 165, 0, 0.3)", stroke_width = 2, stroke_color = '#e00', background_image = image.im, width = image.im.width, height = image.im.height, drawing_mode = "line", key = "canvas", ) with col2: line_seq = ['UP','DP','RPA', 'RG'] h_line_options = list(pitch.horiz_lines.keys()) v_line_options = list(pitch.vert_lines.keys()) hlines = [st.selectbox(f'Horizontal Line #{x+1}', h_line_options, key=f'hline {x}', index=h_line_options.index(line_seq[x])) for x in range(2)] vlines = [st.selectbox(f'Vertical Line #{x+1}', v_line_options, key=f'vline {x}', index=v_line_options.index(line_seq[x+2]))
col21, col22 = st.beta_columns(2) with col22: st.text(".. then click the button ") update_button = st.button('Classify Digit') with col21: st.text("draw in the canvas ..") # Create a canvas component canvas_result = st_canvas( fill_color="rgba(255, 165, 0, 0.3)", # Fixed fill color with some opacity stroke_width=stroke_width, stroke_color=stroke_color, background_color= bg_color, background_image=None, update_streamlit=update_button, height=280, width=280, drawing_mode=drawing_mode, key="canvas", ) # Do something interesting with the image data if (canvas_result.image_data is not None): scaled_img = canvas_result.image_data[::10,::10,:] dnn_img = scaled_img[:,:,0] dnn_img = dnn_img/255.0 dnn_img += 1.0 dnn_img[dnn_img>1.0] = 0.0 result = model.predict(dnn_img.reshape([1, 28,28,1]))[0]
orig_image = np.array(Image.open(bg_image)) image = np.uint8(np.stack((orig_image, ) * 3, axis=-1)) mask_red = np.zeros(image.shape) mask_red[:, :] = (255, 0, 0) mask_red = np.uint8(mask_red * gt_mask[:, :, np.newaxis]) image[mask_red > 0] = image[mask_red > 0] * 0.5 + mask_red[mask_red > 0] * 0.5 image = Image.fromarray(image) # Create a canvas component canvas_result = st_canvas( fill_color="rgba(255, 165, 0, 0.3)", # Fixed fill color with some opacity stroke_width=stroke_width, stroke_color=stroke_color, background_color="", background_image=image, update_streamlit=realtime_update, height=512, width=512, drawing_mode=drawing_mode, key="canvas", ) if canvas_result.json_data is not None and bg_image is not None and gt_mask_file is not None: results = canvas_result.json_data["objects"] mask = np.zeros((1024, 1024), dtype=bool) for res in results: mask[int(res["top"]) * 2:(int(res["top"]) + int(res["height"])) * 2, int(res["left"]) * 2:(int(res["left"]) + int(res["width"])) * 2] = 1
# target choice target = st.sidebar.selectbox(text["what"], (text["digits"], text["letters"])) if target == text["digits"]: target = "digits" else: target = "letters" # Create canva CanvasResult = st_canvas( fill_color="rgba(255, 165, 0, 0.3)", stroke_width=20, stroke_color="#D01111", background_color="#fff", background_image=None, update_streamlit=True, height=CANVA_SIZE, width=CANVA_SIZE, drawing_mode="freedraw", key="canvas", ) # Empty slot for expected input res_text = st.empty() # Next input button change = st.button(text["next"][target]) # Empty slot for score score = st.empty()
if option_upload == 'Draw your own image': # Specify canvas parameters in application stroke_width = st.sidebar.slider("Stroke width: ", 1, 25, 3) stroke_color = st.sidebar.color_picker("Stroke color hex: ") bg_color = st.sidebar.color_picker("Background color hex: ", "#eee") bg_image = st.sidebar.file_uploader("Background image:", type=["png", "jpg"]) drawing_mode = st.sidebar.selectbox( "Drawing tool:", ("freedraw", "line", "rect", "circle", "transform") ) realtime_update = st.sidebar.checkbox("Update in realtime", True) # Create a canvas component canvas_result = st_canvas( fill_color="rgba(255, 165, 0, 0.3)", # Fixed fill color with some opacity stroke_width=stroke_width, stroke_color=stroke_color, background_color=bg_color, background_image=Image.open(bg_image) if bg_image else None, update_streamlit=realtime_update, height=300, width=700, drawing_mode=drawing_mode, key="canvas", ) # Do something interesting with the image data and paths if canvas_result.image_data is not None: display_img = canvas_result.image_data img = PILImageBW.create(display_img[:, :, 0].astype(np.uint8)) if st.button('Predict'): predict(img)
def main(): # INITIALIZATION # For local testing #set_env_variables() url_base = os.environ['URL_BASE'] secret_key = os.environ['SECRET_KEY'] headers = {'Authorization': 'Token ' + secret_key} proxies = { "http": os.environ['QUOTAGUARDSHIELD_URL'], "https": os.environ['QUOTAGUARDSHIELD_URL'] } ## SIDEBAR st.set_option('deprecation.showfileUploaderEncoding', False) st.sidebar.header('User Input') # Collects user input features into dataframe uploaded_file = st.sidebar.file_uploader("Upload your input image file", type=["png", 'jpg', 'jpeg']) pet_type = st.sidebar.selectbox("Pet Type:", ("cat", "dog")) ## S3 Connection aws_key = os.environ['AWS_ACCESS_KEY_ID'] aws_secret = os.environ['AWS_SECRET_ACCESS_KEY'] s3 = boto3.client('s3', aws_access_key_id=aws_key, aws_secret_access_key=aws_secret) default_img_path = 'https://petfacebucket.s3.amazonaws.com' folder_path = 'cat_test' test_distance = 0.6 ## LOAD DATABASE json_path = '00_db/db_' + pet_type + '.json' # json_path = 'db_cat.json' with open(json_path, "r") as jsonfile: db = json.load(jsonfile) if uploaded_file is not None: st.write(""" # Test PetFace App """) img_pil = Image.open(uploaded_file).convert("RGB") img_np = np.array(img_pil) img_np = img_np[:, :, :3] url = url_base + 'pet_face' buffer = io.BytesIO() img_pil.save(buffer, format="JPEG") img_b64 = base64.b64encode(buffer.getvalue()) data = { 'pet_type': [pet_type], 'image': img_b64.decode(), 'is_base64': True } response = requests.post(url, data=json.dumps(data), headers=headers, proxies=proxies) if response.ok: boxes = response.json()['boxes'] kpts = response.json()['kpts'] labels = response.json()['pet_types'] embs = response.json()['embs'] if not st.sidebar.checkbox("Wrong picture processed"): if len(boxes) > 0: col1, col2 = st.beta_columns(2) # processing only first pet kpt = np.array(kpts[0]) y, x, y2, x2 = boxes[0] fig, ax = plt.subplots(1) ax.imshow(img_np) rect = patches.Rectangle((x, y), x2 - x, y2 - y, linewidth=1, edgecolor='b', facecolor='none') ax.add_patch(rect) ax.plot(kpt[:, 0::2], kpt[:, 1::2], 'o') plt.axis('off') col1.pyplot(fig) col2.subheader( "This is your original picture with eyes and nose detected. Below you'll find your pet face aligned" ) leye, reye, nose = fix_eyes(kpt[0], kpt[1], kpt[2], num_eyes=2) face_aligned = get_face_aligned(img_np, leye, reye, nose, pet_type) col2.image(face_aligned, use_column_width='auto') col2.subheader( "Does the picture is correctly detected?. Please answer in the sidebar" ) if pet_type in labels: emb = np.array(embs[0]) t = st.empty() t.info( "getting similar {}s in our db".format(pet_type)) get_similar_pictures(db, emb, default_img_path, pet_type, test_distance=test_distance) t.success("Success!") else: st.write( "No {}s found, please check the pet type".format( pet_type)) else: st.write( "No {}s found, please check 'Wrong picture processed to manually annotate'" .format(pet_type)) else: st.write( "Please help us identify the eyes and the nose of your pet." ) st.write( "Using the drawing tool at the sidebar select circle and annotate the eyes and nose of your pet (no particular order)" ) st.write( "You can also select rectangle from the drawing tool and create a rectangle around your pet head" ) st.write( "If necessary use the transform selection at the sidebar to modify your annotations; \n" "aditionaly use the undo, redo and trash buttons near the picture" ) canvas_h = 300 canvas_w = 600 drawing_mode = st.sidebar.selectbox( "Drawing tool:", ("circle", "rect", "transform")) canvas_result = st_canvas( fill_color= "rgba(255, 165, 0, 0.3)", # Fixed fill color with some opacity stroke_width=2, stroke_color='blue', background_color="", background_image=img_pil, update_streamlit=True, drawing_mode=drawing_mode, key="canvas", ) if canvas_result.json_data is not None: df = pd.json_normalize(canvas_result.json_data["objects"]) if len(df) > 1: leye, reye, nose = [], [], [] kpts = df.loc[df.type == 'circle', ['left', 'top']].values h, w, _ = img_np.shape ratio_factor = (w / h) * (canvas_h / canvas_w) kpts = kpts * [(h / canvas_h) * ratio_factor, (w / canvas_w) * (1 / ratio_factor)] if len(kpts) <= 2: leye, reye, nose = fix_eyes(kpts[0], kpts[0], kpts[1], num_eyes=1) if len(kpts) > 2: leye, reye, nose = fix_eyes(kpts[0], kpts[1], kpts[2], num_eyes=2) face_aligned = get_face_aligned( img_np, leye, reye, nose, pet_type) col1, col2 = st.beta_columns(2) col2.subheader( "This is the picture of your {} aligned!".format( pet_type)) col1.image(face_aligned) url_emb = url_base + 'emb' data = { 'image': face_aligned.tolist(), 'pet_type': pet_type } response_emb = requests.post(url_emb, data=json.dumps(data), headers=headers, proxies=proxies) if response_emb.ok: emb = np.array(response_emb.json()['emb']) t = st.empty() t.info("getting similar {}s in our db".format( pet_type)) get_similar_pictures(db, emb, default_img_path, pet_type, test_distance=test_distance) t.success("Success!") else: st.write( "There was a problem connecting to the server, please try again later" ) else: st.write(""" # Test PetFace App This app is a *test*, please upload an image and specify the pet type at the menu on the left """)
model = VGG_FeatureExtractor(len(character)) model.load_weights(saved_model) return model, list(character) model, idx2char = load_model() st.write('# 한글 음절 인식기') col1, col2 = st.beta_columns(2) with col1: canvas = st_canvas( fill_color='#FFFFFF', stroke_width=7, stroke_color='#000000', background_color='#FFFFFF', width=192, height=192, drawing_mode='freedraw', key='canvas' ) if canvas.image_data is not None: # image load img = canvas.image_data.astype('uint8') img = cv2.resize(img, (32, 32)) preview_img = cv2.resize(img, (192, 192)) # show image for feeding to model col2.image(preview_img) # preprocess image
[Deep Detect Handwriting repository](https://github.com/leersmathieu/deep-detect-handwriting) """) col1, col2 = st.beta_columns(2) with col1: # Display a h3 title st.subheader("Drawing area") st.markdown("Draw a digit and then press 'Get prediction'") # Create a canvas component canvas_result = st_canvas( stroke_width=20, stroke_color="#fff", background_color="#000", update_streamlit=True, height=280, width=280, drawing_mode="freedraw", key="canvas", ) if st.button('Get prediction'): model = Model() # Instantiate an Image object from the handwritten canvas image = Image(canvas_result.image_data) with col2: # Display a h2 title st.subheader("What the computer see") st.markdown("Your drawing is resized and gray-scaled")
37: 'sha',38: 'oo', 39: 'au', 40: 'pha', 41: 'ee', 42: '4', 43: 'dha', 44: '9', 45: 'u', 46: 'daa', 47: 'i', 48: '1', 49: 'ha', 50: 'rda', 51: 'ba', 52: 'ksha', 53: 'jha', 54: 'katasha', 55: '0', 56: 'ja', 57:'ya' } return mapping[pred] tf.config.experimental.set_memory_growth(tf.config.experimental.list_physical_devices('GPU')[0], True) st.title("Hindi character recognition") st.write("Draw a hindi character below and click on Predict button") st.write("\n") st.write("To clear the digit, uncheck checkbox, double click on the digit or refresh the page") st.write("To draw the digit, check the checkbox") drawing_mode = st.checkbox("Draw?",True) image_data = st_canvas(15, '#000', '#FFF', height=400,width=400, drawing_mode=drawing_mode, key="canvas") check=st.button("Predict") st.set_option('deprecation.showfileUploaderEncoding', False) if image_data is not None: if check: cv2.imwrite("test.jpg",image_data) im = np.array(Image.open("test.jpg").convert('RGB').resize((224,224),Image.BICUBIC)) st.title("Input Image") st.image(im) im=im/255.0 im_preprocess=np.expand_dims(im, axis=0) infer_model=inference_model() infer_model.load_weights("../weights/prototype.h5")
st.title(text[value]["title"]) st.markdown(f"**{alfabeto_espacio}**") st.markdown(f"{text[value]['instruction']}") # Specify brush parameters and drawing mode stroke_width = st.sidebar.slider("{}: ".format(text[value]["stroke width"]), 1, 100, 25) stroke_color = st.sidebar.color_picker("{}:".format(text[value]["color"])) # Create a canvas component canvas_result = st_canvas( stroke_width=stroke_width, stroke_color=stroke_color, background_color="#FFF", height=280, width=280, drawing_mode="freedraw", key="canvas", ) predict = st.button(text[value]["predict"]) def get_prediction(image): pass if canvas_result.image_data is not None and predict: # 1: Obtengo la imagen del canvas imagen = canvas_result.image_data
st.title('¡RECONOCE DÍGITOS!') st.markdown(''' La siguiente aplicación intenta predecir el dígito escrito. * Usamos redes neuronales convolucionales con Tensorflow. * Para identificar reglas de decisión usamos LIME. * Para reducir dimensiones usamos UMAP. * Para buscar imágenes similares usamos NearestNeighbors. ''') st.markdown('''¡ESCRIBA UN DÍGITO, INTENTARÉ PREDECIRLO!''') canvas_result = st_canvas(fill_color='#000000', stroke_width=20, stroke_color='#FFFFFF', background_color='#000000', width=config.SIZE_DRAW, height=config.SIZE_DRAW, drawing_mode='freedraw', key='canvas') if canvas_result.image_data is not None: if st.button('PREDECIR'): image_array = canvas_result.image_data.astype(np.uint8) img = prepara_img(image_array=image_array) st.subheader('PREDICCIÓN') predict_class(img) st.subheader('LIME PARA REGLAS DE DECISIÓN') plot_rules(img)
expander_bar = st.beta_expander("About") expander_bar.markdown(""" * **Python libraries: streamlit, streamlit_drawable_canvas, pandas, numpy, tensorflow, skimage** * **Source of data: MNIST dataset from tensorflow.keras.datasets, which contains 70,000 images (28x28 pixels) of the numbers from 0 to 9 handwritten by US highschool students.** """) st.write("") st.write("Try to draw a number here:") canvas_result = st_canvas( fill_color= "rgba(255, 165, 0, 0.3)", # Fixed fill color with some opacity stroke_width=50, stroke_color="000000", background_color="#FFFFFF", background_image=None, update_streamlit=True, height=500, width=500, drawing_mode="freedraw", initial_drawing=None, key="full_app", ) if st.button("Click here to let the CNN model make a prediction"): # convert the drawn canvas to image format and get a prediction from our pretrained model if canvas_result.image_data is not None: # load model tf_model = load_model()
return load_model('model.h5') model = load() st.write('# MNIST Recognizer') CANVAS_SIZE = 192 col1, col2 = st.beta_columns(2) with col1: canvas = st_canvas(fill_color='#000000', stroke_width=20, stroke_color='#FFFFFF', background_color='#000000', width=CANVAS_SIZE, height=CANVAS_SIZE, drawing_mode='freedraw', key='canvas') if canvas.image_data is not None: img = canvas.image_data.astype(np.uint8) img = cv2.resize(img, dsize=(28, 28)) preview_img = cv2.resize(img, dsize=(CANVAS_SIZE, CANVAS_SIZE), interpolation=cv2.INTER_NEAREST) col2.image(preview_img) x = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) x = x.reshape((-1, 28, 28, 1))
# st.markdown('<style>body{color: White; background-color: DarkSlateGrey}</style>', unsafe_allow_html=True) st.title('My Digit Recognizer') st.markdown(''' Try to write a digit! ''') # data = np.random.rand(28,28) # img = cv2.resize(data, (256, 256), interpolation=cv2.INTER_NEAREST) SIZE = 192 mode = st.checkbox("Draw (or Delete)?", True) canvas_result = st_canvas(fill_color='#000000', stroke_width=20, stroke_color='#FFFFFF', background_color='#000000', width=SIZE, height=SIZE, drawing_mode="freedraw" if mode else "transform", key='canvas') if canvas_result.image_data is not None: img = cv2.resize(canvas_result.image_data.astype('uint8'), (28, 28)) rescaled = cv2.resize(img, (SIZE, SIZE), interpolation=cv2.INTER_NEAREST) st.write('Model Input') st.image(rescaled) if st.button('Predict'): test_x = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) val = model.predict(test_x.reshape(1, 28, 28)) st.write(f'result: {np.argmax(val[0])}') st.bar_chart(val[0])
from code import config from PIL import Image from torchvision import transforms import numpy as np import cv2 from torchvision.utils import save_image st.header('Sketch to Shoe') st.subheader('Image to image translation: a reimplementation of pix2pix GAN') st.write('Project Sketch-to-Shoe is a thorough yet comprehensible reimplementation of the pix2pix GAN paper (Isola et al.)') st.write('It adheres to the PyTorch framework and is trained on various sketches/images of shoes.') st.image('assets/120_AB.jpg') stwid = st.sidebar.slider('Width of brush: ',1,10,2) color = st.sidebar.color_picker('Choose the color you want: ') img_dat = st_canvas(stroke_width=stwid,stroke_color=color, background_color='#000',height=300,width=400, drawing_mode='freedraw',key='canvas') cv2.imwrite(r'samples/inp.jpg',img_dat.image_data) img = Image.open(r'samples/inp.jpg').resize((256, 256), Image.ANTIALIAS).convert('RGB') img = np.asarray(img, dtype='uint8') transf = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5,),(0.5,))]) img = transf(img) img = img.unsqueeze(0) img = img.to(config.device) x = st.button('pix2pix') gen = Generator(in_channels=3).to(config.device) saved = torch.load(r'D:\pix2pix_models\gmodel.pth',map_location=config.device) gen.load_state_dict(saved['model']) gen.eval()
def main(): def convertImage(image): if image is not None: image = Image.fromarray(np.uint8(image)).convert('L') image = np.array(image) while np.sum(image[0]) == 0: image = image[1:] while np.sum(image[:, 0]) == 0: image = np.delete(image, 0, 1) while np.sum(image[-1]) == 0: image = image[:-1] while np.sum(image[:, -1]) == 0: image = np.delete(image, -1, 1) rows, cols = image.shape colsPadding = (int(math.ceil( (308 - cols) / 2.0)), int(math.floor((308 - cols) / 2.0))) rowsPadding = (int(math.ceil( (308 - rows) / 2.0)), int(math.floor((308 - rows) / 2.0))) image = np.lib.pad(image, (rowsPadding, colsPadding), 'constant') image = Image.fromarray(np.uint8(image)) image = image.resize(size=(28, 28)) st.image(image) image = np.array(image) image = image.reshape(1, 28, 28, 1) image = convert_to_tensor(image) return image def loadModel(): model = load_model('./saved_model.h5', compile=True) return model def prediction(m, d): pred = m(d, training=False) pred = pred.numpy() return pred # Load the model model = loadModel() st.write(""" #My first app Hello World """) # Specify brush parameters and drawing mode drawing_mode = st.sidebar.selectbox("Drawing mode", ("freedraw", "line", "transform")) key = "canvas" # Create a canvas component image_data = st_canvas( 20, "#FFF", "#000", height=308, width=308, drawing_mode=drawing_mode, key=key, ) if image_data is not None: if np.mean(image_data) != 63.75: data = convertImage(image_data) pred = prediction(model, data) xt = ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9') y_pos = np.arange(len(xt)) plt.bar(y_pos, height=pred[0], align='center', color=[ 'blue', 'red', 'orange', 'green', 'black', 'cyan', 'yellow', 'purple', 'magenta', 'pink' ]) plt.xticks(y_pos, xt) st.pyplot(plt)
image_to_open = st.sidebar.file_uploader("Upload Image:", type=["png", "jpg"]) if image_to_open: st.title('Pitch lines') st.sidebar.write('Draw Penalty Box lines in the order shown below:') st.sidebar.image('pitch.png', width=300) image = Image.open(image_to_open) image = image.resize((500, int(500*image.height/image.width))) # Create a canvas component to draw pitch lines canvas_image = st_canvas( fill_color = "rgba(255, 165, 0, 0.3)", stroke_width = 2, stroke_color = "#e00", background_image=image, width = image.width, height = image.height, drawing_mode= "line", key="canvas", ) if canvas_image.json_data["objects"]: if len(canvas_image.json_data["objects"])>=4: df = pd.json_normalize(canvas_image.json_data["objects"]) df['y1_line'] = df['top']+df['y1'] df['y2_line'] = df['top']+df['y2'] df['x1_line'] = df['left']+df['x1'] df['x2_line'] = df['left']+df['x2'] df['slope'], df['intercept'] = get_si_from_coords(df[['x1_line', 'y1_line', 'x2_line', 'y2_line']].values) UP_PA = line_intersect(df.loc[0, ['slope', 'intercept']], df.loc[2, ['slope', 'intercept']])