Mehdi Cherti mehdidc

With the release of Vivaldi 2.2, this page is now obsolete and unmaintained. Widevine is fetched automatically on post install of our official packages. The information below and the script are left for historical reasons but will not be updated.

If you are using something newer than Vivaldi 2.2, you should not be using this script as there is simply no need. Any need you think you have for it would be a bug IMHO and thus should be logged in a bug report. Before you do so however, you should also checkout the Vivaldi help page on Widevine, on Linux

Summary

A bunch of people asked how they could use this script with pure Chromium on Ubuntu. The following is a quick guide. Though I still suggest you at least try Vivaldi. Who knows, you might like it. Worried about proprietary componants? Remember that libwidevinecdm.so is a b

Using Python 3 + Google Cloud Vision API's OCR to extract text from photos and scanned documents

Just a quickie test in Python 3 (using Requests) to see if Google Cloud Vision can be used to effectively OCR a scanned data table and preserve its structure, in the way that products such as ABBYY FineReader can OCR an image and provide Excel-ready output.

The short answer: No. While Cloud Vision provides bounding polygon coordinates in its output, it doesn't provide it at the word or region level, which would be needed to then calculate the data delimiters.

On the other hand, the OCR quality is pretty good, if you just need to identify text anywhere in an image, without regards to its physical coordinates. I've included two examples:

####### 1. A low-resolution photo of road signs

A Few Useful Things to Know about Machine Learning

The paper presents some key lessons and "folk wisdom" that machine learning researchers and practitioners have learnt from experience and which are hard to find in textbooks.

1. Learning = Representation + Evaluation + Optimization

All machine learning algorithms have three components:

Representation for a learner is the set if classifiers/functions that can be possibly learnt. This set is called hypothesis space. If a function is not in hypothesis space, it can not be learnt.
Evaluation function tells how good the machine learning model is.
Optimisation is the method to search for the most optimal learning model.

	n02119789 1 kit_fox
	n02100735 2 English_setter
	n02110185 3 Siberian_husky
	n02096294 4 Australian_terrier
	n02102040 5 English_springer
	n02066245 6 grey_whale
	n02509815 7 lesser_panda
	n02124075 8 Egyptian_cat
	n02417914 9 ibex
	n02123394 10 Persian_cat

	"""
	Implementation of 'Maximum Likelihood Estimation of Intrinsic Dimension' by Elizaveta Levina and Peter J. Bickel

	how to use
	----------

	The goal is to estimate intrinsic dimensionality of data, the estimation of dimensionality is scale dependent
	(depending on how much you zoom into the data distribution you can find different dimesionality), so they
	propose to average it over different scales, the interval of the scales [k1, k2] are the only parameters of the algorithm.

	{0: 'tench, Tinca tinca',
	1: 'goldfish, Carassius auratus',
	2: 'great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias',
	3: 'tiger shark, Galeocerdo cuvieri',
	4: 'hammerhead, hammerhead shark',
	5: 'electric ray, crampfish, numbfish, torpedo',
	6: 'stingray',
	7: 'cock',
	8: 'hen',
	9: 'ostrich, Struthio camelus',

	# Author: Kyle Kastner
	# License: BSD 3-Clause
	# Implementing http://mnemstudio.org/path-finding-q-learning-tutorial.htm
	# Q-learning formula from http://sarvagyavaish.github.io/FlappyBirdRL/
	# Visualization based on code from Gael Varoquaux [email protected]
	# http://scikit-learn.org/stable/auto_examples/applications/plot_stock_market.html

	import numpy as np
	import matplotlib.pyplot as plt
	from matplotlib.collections import LineCollection

	from __future__ import absolute_import
	from __future__ import print_function
	import numpy as np
	np.random.seed(1337) # for reproducibility

	import random
	from keras.datasets import mnist
	from keras.models import Sequential
	from keras.layers.core import *
	from keras.optimizers import SGD, RMSprop

	import PIL.Image
	from cStringIO import StringIO
	import IPython.display
	import numpy as np
	def showarray(a, fmt='png'):
	a = np.uint8(a)
	f = StringIO()
	PIL.Image.fromarray(a).save(f, fmt)
	IPython.display.display(IPython.display.Image(data=f.getvalue()))