markdown
stringlengths
0
37k
code
stringlengths
1
33.3k
path
stringlengths
8
215
repo_name
stringlengths
6
77
license
stringclasses
15 values
First, we'll download the dataset to our local machine. The data consists of characters rendered in a variety of fonts on a 28x28 image. The labels are limited to 'A' through 'J' (10 classes). The training set has about 500k and the testset 19000 labeled examples. Given these sizes, it should be possible to train models quickly on any machine.
url = 'https://commondatastorage.googleapis.com/books1000/' last_percent_reported = None data_root = '.' # Change me to store data elsewhere def download_progress_hook(count, blockSize, totalSize): """A hook to report the progress of a download. This is mostly intended for users with slow internet connections. Reports every 5% change in download progress. """ global last_percent_reported percent = int(count * blockSize * 100 / totalSize) if last_percent_reported != percent: if percent % 5 == 0: sys.stdout.write("%s%%" % percent) sys.stdout.flush() else: sys.stdout.write(".") sys.stdout.flush() last_percent_reported = percent def maybe_download(filename, expected_bytes, force=False): """Download a file if not present, and make sure it's the right size.""" dest_filename = os.path.join(data_root, filename) if force or not os.path.exists(dest_filename): print('Attempting to download:', filename) filename, _ = urlretrieve(url + filename, dest_filename, reporthook=download_progress_hook) print('\nDownload Complete!') statinfo = os.stat(dest_filename) if statinfo.st_size == expected_bytes: print('Found and verified', dest_filename) else: raise Exception( 'Failed to verify ' + dest_filename + '. Can you get to it with a browser?') return dest_filename train_filename = maybe_download('notMNIST_large.tar.gz', 247336696) test_filename = maybe_download('notMNIST_small.tar.gz', 8458043)
machine-learning/deep-learning/udacity/ud730/1_notmnist.ipynb
pk-ai/training
mit
Extract the dataset from the compressed .tar.gz file. This should give you a set of directories, labeled A through J.
num_classes = 10 np.random.seed(133) def maybe_extract(filename, force=False): root = os.path.splitext(os.path.splitext(filename)[0])[0] # remove .tar.gz if os.path.isdir(root) and not force: # You may override by setting force=True. print('%s already present - Skipping extraction of %s.' % (root, filename)) else: print('Extracting data for %s. This may take a while. Please wait.' % root) tar = tarfile.open(filename) sys.stdout.flush() tar.extractall(data_root) tar.close() data_folders = [ os.path.join(root, d) for d in sorted(os.listdir(root)) if os.path.isdir(os.path.join(root, d))] if len(data_folders) != num_classes: raise Exception( 'Expected %d folders, one per class. Found %d instead.' % ( num_classes, len(data_folders))) print(data_folders) return data_folders train_folders = maybe_extract(train_filename) test_folders = maybe_extract(test_filename)
machine-learning/deep-learning/udacity/ud730/1_notmnist.ipynb
pk-ai/training
mit
Problem 1 Let's take a peek at some of the data to make sure it looks sensible. Each exemplar should be an image of a character A through J rendered in a different font. Display a sample of the images that we just downloaded. Hint: you can use the package IPython.display.
# Solution for Problem 1 import random print('Displaying images of train folders') # Looping through train folders and displaying a random image of each folder for path in train_folders: image_file = os.path.join(path, random.choice(os.listdir(path))) display(Image(filename=image_file)) print('Displaying images of test folders') # Looping through train folders and displaying a random image of each folder for path in test_folders: image_file = os.path.join(path, random.choice(os.listdir(path))) display(Image(filename=image_file))
machine-learning/deep-learning/udacity/ud730/1_notmnist.ipynb
pk-ai/training
mit
Now let's load the data in a more manageable format. Since, depending on your computer setup you might not be able to fit it all in memory, we'll load each class into a separate dataset, store them on disk and curate them independently. Later we'll merge them into a single dataset of manageable size. We'll convert the entire dataset into a 3D array (image index, x, y) of floating point values, normalized to have approximately zero mean and standard deviation ~0.5 to make training easier down the road. A few images might not be readable, we'll just skip them.
image_size = 28 # Pixel width and height. pixel_depth = 255.0 # Number of levels per pixel. def load_letter(folder, min_num_images): """Load the data for a single letter label.""" image_files = os.listdir(folder) dataset = np.ndarray(shape=(len(image_files), image_size, image_size), dtype=np.float32) print(folder) num_images = 0 for image in image_files: image_file = os.path.join(folder, image) try: image_data = (ndimage.imread(image_file).astype(float) - pixel_depth / 2) / pixel_depth if image_data.shape != (image_size, image_size): raise Exception('Unexpected image shape: %s' % str(image_data.shape)) dataset[num_images, :, :] = image_data num_images = num_images + 1 except IOError as e: print('Could not read:', image_file, ':', e, '- it\'s ok, skipping.') dataset = dataset[0:num_images, :, :] if num_images < min_num_images: raise Exception('Many fewer images than expected: %d < %d' % (num_images, min_num_images)) print('Full dataset tensor:', dataset.shape) print('Mean:', np.mean(dataset)) print('Standard deviation:', np.std(dataset)) return dataset def maybe_pickle(data_folders, min_num_images_per_class, force=False): dataset_names = [] for folder in data_folders: set_filename = folder + '.pickle' dataset_names.append(set_filename) if os.path.exists(set_filename) and not force: # You may override by setting force=True. print('%s already present - Skipping pickling.' % set_filename) else: print('Pickling %s.' % set_filename) dataset = load_letter(folder, min_num_images_per_class) try: with open(set_filename, 'wb') as f: pickle.dump(dataset, f, pickle.HIGHEST_PROTOCOL) except Exception as e: print('Unable to save data to', set_filename, ':', e) return dataset_names train_datasets = maybe_pickle(train_folders, 45000) test_datasets = maybe_pickle(test_folders, 1800)
machine-learning/deep-learning/udacity/ud730/1_notmnist.ipynb
pk-ai/training
mit
Problem 2 Let's verify that the data still looks good. Displaying a sample of the labels and images from the ndarray. Hint: you can use matplotlib.pyplot.
# Solution for Problem 2 def show_first_image(datasets): for pickl in datasets: print('Showing a first image from pickle ', pickl) try: with open(pickl, 'rb') as f: letter_set = pickle.load(f) plt.imshow(letter_set[0]) except Exception as e: print('Unable to show image from pickle ', pickl, ':', e) raise print('From Training dataset') show_first_image(train_datasets) print('From Test Dataset') show_first_image(test_datasets)
machine-learning/deep-learning/udacity/ud730/1_notmnist.ipynb
pk-ai/training
mit
Problem 3 Another check: we expect the data to be balanced across classes. Verify that.
def show_dataset_shape(datasets): for pickl in datasets: try: with open(pickl, 'rb') as f: letter_set = pickle.load(f) print('Shape of pickle ', pickl, 'is', np.shape(letter_set)) except Exception as e: print('Unable to show image from pickle ', pickl, ':', e) raise print('Shape for Training set') show_dataset_shape(train_datasets) print('Shape for Test set') show_dataset_shape(test_datasets)
machine-learning/deep-learning/udacity/ud730/1_notmnist.ipynb
pk-ai/training
mit
Merge and prune the training data as needed. Depending on your computer setup, you might not be able to fit it all in memory, and you can tune train_size as needed. The labels will be stored into a separate array of integers 0 through 9. Also create a validation dataset for hyperparameter tuning.
def make_arrays(nb_rows, img_size): if nb_rows: dataset = np.ndarray((nb_rows, img_size, img_size), dtype=np.float32) labels = np.ndarray(nb_rows, dtype=np.int32) else: dataset, labels = None, None return dataset, labels def merge_datasets(pickle_files, train_size, valid_size=0): num_classes = len(pickle_files) valid_dataset, valid_labels = make_arrays(valid_size, image_size) train_dataset, train_labels = make_arrays(train_size, image_size) vsize_per_class = valid_size // num_classes tsize_per_class = train_size // num_classes start_v, start_t = 0, 0 end_v, end_t = vsize_per_class, tsize_per_class end_l = vsize_per_class+tsize_per_class for label, pickle_file in enumerate(pickle_files): try: with open(pickle_file, 'rb') as f: letter_set = pickle.load(f) # let's shuffle the letters to have random validation and training set np.random.shuffle(letter_set) if valid_dataset is not None: valid_letter = letter_set[:vsize_per_class, :, :] valid_dataset[start_v:end_v, :, :] = valid_letter valid_labels[start_v:end_v] = label start_v += vsize_per_class end_v += vsize_per_class train_letter = letter_set[vsize_per_class:end_l, :, :] train_dataset[start_t:end_t, :, :] = train_letter train_labels[start_t:end_t] = label start_t += tsize_per_class end_t += tsize_per_class except Exception as e: print('Unable to process data from', pickle_file, ':', e) raise return valid_dataset, valid_labels, train_dataset, train_labels """ train_size = 200000 valid_size = 10000 test_size = 10000 """ train_size = 20000 valid_size = 1000 test_size = 1000 valid_dataset, valid_labels, train_dataset, train_labels = merge_datasets( train_datasets, train_size, valid_size) _, _, test_dataset, test_labels = merge_datasets(test_datasets, test_size) print('Training:', train_dataset.shape, train_labels.shape) print('Validation:', valid_dataset.shape, valid_labels.shape) print('Testing:', test_dataset.shape, test_labels.shape)
machine-learning/deep-learning/udacity/ud730/1_notmnist.ipynb
pk-ai/training
mit
Next, we'll randomize the data. It's important to have the labels well shuffled for the training and test distributions to match.
def randomize(dataset, labels): permutation = np.random.permutation(labels.shape[0]) shuffled_dataset = dataset[permutation,:,:] shuffled_labels = labels[permutation] return shuffled_dataset, shuffled_labels train_dataset, train_labels = randomize(train_dataset, train_labels) test_dataset, test_labels = randomize(test_dataset, test_labels) valid_dataset, valid_labels = randomize(valid_dataset, valid_labels)
machine-learning/deep-learning/udacity/ud730/1_notmnist.ipynb
pk-ai/training
mit
Problem 4 Convince yourself that the data is still good after shuffling!
print('Printing Train, validation and test labels after shuffling') def print_first_10_labels(labels): printing_labels = [] for i in range(10): printing_labels.append(labels[[i]]) print(printing_labels) print_first_10_labels(train_labels) print_first_10_labels(test_labels) print_first_10_labels(valid_labels)
machine-learning/deep-learning/udacity/ud730/1_notmnist.ipynb
pk-ai/training
mit
Finally, let's save the data for later reuse:
pickle_file = os.path.join(data_root, 'notMNIST.pickle') try: f = open(pickle_file, 'wb') save = { 'train_dataset': train_dataset, 'train_labels': train_labels, 'valid_dataset': valid_dataset, 'valid_labels': valid_labels, 'test_dataset': test_dataset, 'test_labels': test_labels, } pickle.dump(save, f, pickle.HIGHEST_PROTOCOL) f.close() except Exception as e: print('Unable to save data to', pickle_file, ':', e) raise statinfo = os.stat(pickle_file) print('Compressed pickle size:', statinfo.st_size)
machine-learning/deep-learning/udacity/ud730/1_notmnist.ipynb
pk-ai/training
mit
Problem 5 By construction, this dataset might contain a lot of overlapping samples, including training data that's also contained in the validation and test set! Overlap between training and test can skew the results if you expect to use your model in an environment where there is never an overlap, but are actually ok if you expect to see training samples recur when you use it. Measure how much overlap there is between training, validation and test samples. Optional questions: - What about near duplicates between datasets? (images that are almost identical) - Create a sanitized validation and test set, and compare your accuracy on those in subsequent assignments. Problem 6 Let's get an idea of what an off-the-shelf classifier can give you on this data. It's always good to check that there is something to learn, and that it's a problem that is not so trivial that a canned solution solves it. Train a simple model on this data using 50, 100, 1000 and 5000 training samples. Hint: you can use the LogisticRegression model from sklearn.linear_model. Optional question: train an off-the-shelf model on all the data!
logreg_model_clf = LogisticRegression() nsamples, nx, ny = train_dataset.shape d2_train_dataset = train_dataset.reshape((nsamples,nx*ny)) logreg_model_clf.fit(d2_train_dataset, train_labels) from sklearn.metrics import accuracy_score nsamples, nx, ny = valid_dataset.shape d2_valid_dataset = valid_dataset.reshape((nsamples,nx*ny)) print("validation accuracy,", accuracy_score(valid_labels, logreg_model_clf.predict(d2_valid_dataset))) nsamples, nx, ny = test_dataset.shape d2_train_dataset = test_dataset.reshape((nsamples,nx*ny)) print("test accuracy,", accuracy_score(test_labels, logreg_model_clf.predict(d2_train_dataset)))
machine-learning/deep-learning/udacity/ud730/1_notmnist.ipynb
pk-ai/training
mit
Now the Hotels
url = 'http://www.bringfido.com/lodging/city/new_haven_ct_us' r = Render(url) result = r.frame.toHtml() #QString should be converted to string before processed by lxml formatted_result = str(result.toAscii()) tree = html.fromstring(formatted_result) #Now using correct Xpath we are fetching URL of archives archive_links = tree.xpath('//*[@id="results_list"]/div') print(archive_links) print('') for lnk in archive_links: print(lnk.xpath('div[2]/h1/a/text()')[0]) print(lnk.text_content()) print('*'*25)
code/.ipynb_checkpoints/bf_qt_scraping-checkpoint.ipynb
mattgiguere/doglodge
mit
Now Get the Links
links = [] for lnk in archive_links: print(lnk.xpath('div/h1/a/@href')[0]) links.append(lnk.xpath('div/h1/a/@href')[0]) print('*'*25) lnk.xpath('//*/div/h1/a/@href')[0] links
code/.ipynb_checkpoints/bf_qt_scraping-checkpoint.ipynb
mattgiguere/doglodge
mit
Loading Reviews Next, we want to step through each page, and scrape the reviews for each hotel.
url_base = 'http://www.bringfido.com' r.update_url(url_base+links[0]) result = r.frame.toHtml() #QString should be converted to string before processed by lxml formatted_result = str(result.toAscii()) tree = html.fromstring(formatted_result) hotel_description = tree.xpath('//*[@class="body"]/text()') details = tree.xpath('//*[@class="address"]/text()') address = details[0] csczip = details[1] phone = details[2] #Now using correct Xpath we are fetching URL of archives reviews = tree.xpath('//*[@class="review_container"]') texts = [] titles = [] authors = [] ratings = [] print(reviews) print('') for rev in reviews: titles.append(rev.xpath('div/div[1]/text()')[0]) authors.append(rev.xpath('div/div[2]/text()')[0]) texts.append(rev.xpath('div/div[3]/text()')[0]) ratings.append(rev.xpath('div[2]/img/@src')[0].split('/')[-1][0:1]) print(rev.xpath('div[2]/img/@src')[0].split('/')[-1][0:1]) titles authors texts ratings
code/.ipynb_checkpoints/bf_qt_scraping-checkpoint.ipynb
mattgiguere/doglodge
mit
Load software and filenames definitions
from fretbursts import * init_notebook() from IPython.display import display
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
Data folder:
data_dir = './data/singlespot/' import os data_dir = os.path.abspath(data_dir) + '/' assert os.path.exists(data_dir), "Path '%s' does not exist." % data_dir
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
List of data files:
from glob import glob file_list = sorted(f for f in glob(data_dir + '*.hdf5') if '_BKG' not in f) ## Selection for POLIMI 2012-11-26 datatset labels = ['17d', '27d', '7d', '12d', '22d'] files_dict = {lab: fname for lab, fname in zip(labels, file_list)} files_dict data_id
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
Data load Initial loading of the data:
d = loader.photon_hdf5(filename=files_dict[data_id])
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
Load the leakage coefficient from disk:
leakage_coeff_fname = 'results/usALEX - leakage coefficient DexDem.csv' leakage = np.loadtxt(leakage_coeff_fname) print('Leakage coefficient:', leakage)
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
Load the direct excitation coefficient ($d_{exAA}$) from disk:
dir_ex_coeff_fname = 'results/usALEX - direct excitation coefficient dir_ex_aa.csv' dir_ex_aa = np.loadtxt(dir_ex_coeff_fname) print('Direct excitation coefficient (dir_ex_aa):', dir_ex_aa)
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
Load the gamma-factor ($\gamma$) from disk:
gamma_fname = 'results/usALEX - gamma factor - all-ph.csv' gamma = np.loadtxt(gamma_fname) print('Gamma-factor:', gamma)
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
Update d with the correction coefficients:
d.leakage = leakage d.dir_ex = dir_ex_aa d.gamma = gamma
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
Laser alternation selection At this point we have only the timestamps and the detector numbers:
d.ph_times_t[0][:3], d.ph_times_t[0][-3:]#, d.det_t print('First and last timestamps: {:10,} {:10,}'.format(d.ph_times_t[0][0], d.ph_times_t[0][-1])) print('Total number of timestamps: {:10,}'.format(d.ph_times_t[0].size))
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
We need to define some parameters: donor and acceptor ch, excitation period and donor and acceptor excitiations:
d.add(det_donor_accept=(0, 1), alex_period=4000, D_ON=(2850, 580), A_ON=(900, 2580), offset=0)
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
We should check if everithing is OK with an alternation histogram:
plot_alternation_hist(d)
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
If the plot looks good we can apply the parameters with:
loader.alex_apply_period(d) print('D+A photons in D-excitation period: {:10,}'.format(d.D_ex[0].sum())) print('D+A photons in A-excitation period: {:10,}'.format(d.A_ex[0].sum()))
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
Measurements infos All the measurement data is in the d variable. We can print it:
d
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
Or check the measurements duration:
d.time_max
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
Compute background Compute the background using automatic threshold:
d.calc_bg(bg.exp_fit, time_s=60, tail_min_us='auto', F_bg=1.7) dplot(d, timetrace_bg) d.rate_m, d.rate_dd, d.rate_ad, d.rate_aa
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
Burst search and selection
d.burst_search(L=10, m=10, F=7, ph_sel=Ph_sel('all')) print(d.ph_sel) dplot(d, hist_fret); # if data_id in ['7d', '27d']: # ds = d.select_bursts(select_bursts.size, th1=20) # else: # ds = d.select_bursts(select_bursts.size, th1=30) ds = d.select_bursts(select_bursts.size, add_naa=False, th1=30) n_bursts_all = ds.num_bursts[0] def select_and_plot_ES(fret_sel, do_sel): ds_fret= ds.select_bursts(select_bursts.ES, **fret_sel) ds_do = ds.select_bursts(select_bursts.ES, **do_sel) bpl.plot_ES_selection(ax, **fret_sel) bpl.plot_ES_selection(ax, **do_sel) return ds_fret, ds_do ax = dplot(ds, hist2d_alex, S_max_norm=2, scatter_alpha=0.1) if data_id == '7d': fret_sel = dict(E1=0.60, E2=1.2, S1=0.2, S2=0.9, rect=False) do_sel = dict(E1=-0.2, E2=0.5, S1=0.8, S2=2, rect=True) ds_fret, ds_do = select_and_plot_ES(fret_sel, do_sel) elif data_id == '12d': fret_sel = dict(E1=0.30,E2=1.2,S1=0.131,S2=0.9, rect=False) do_sel = dict(E1=-0.4, E2=0.4, S1=0.8, S2=2, rect=False) ds_fret, ds_do = select_and_plot_ES(fret_sel, do_sel) elif data_id == '17d': fret_sel = dict(E1=0.01, E2=0.98, S1=0.14, S2=0.88, rect=False) do_sel = dict(E1=-0.4, E2=0.4, S1=0.80, S2=2, rect=False) ds_fret, ds_do = select_and_plot_ES(fret_sel, do_sel) elif data_id == '22d': fret_sel = dict(E1=-0.16, E2=0.6, S1=0.2, S2=0.80, rect=False) do_sel = dict(E1=-0.2, E2=0.4, S1=0.85, S2=2, rect=True) ds_fret, ds_do = select_and_plot_ES(fret_sel, do_sel) elif data_id == '27d': fret_sel = dict(E1=-0.1, E2=0.5, S1=0.2, S2=0.82, rect=False) do_sel = dict(E1=-0.2, E2=0.4, S1=0.88, S2=2, rect=True) ds_fret, ds_do = select_and_plot_ES(fret_sel, do_sel) n_bursts_do = ds_do.num_bursts[0] n_bursts_fret = ds_fret.num_bursts[0] n_bursts_do, n_bursts_fret d_only_frac = 1.*n_bursts_do/(n_bursts_do + n_bursts_fret) print('D-only fraction:', d_only_frac) dplot(ds_fret, hist2d_alex, scatter_alpha=0.1); dplot(ds_do, hist2d_alex, S_max_norm=2, scatter=False);
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
Donor Leakage fit
bandwidth = 0.03 E_range_do = (-0.1, 0.15) E_ax = np.r_[-0.2:0.401:0.0002] E_pr_do_kde = bext.fit_bursts_kde_peak(ds_do, bandwidth=bandwidth, weights='size', x_range=E_range_do, x_ax=E_ax, save_fitter=True) mfit.plot_mfit(ds_do.E_fitter, plot_kde=True, bins=np.r_[E_ax.min(): E_ax.max(): bandwidth]) plt.xlim(-0.3, 0.5) print("%s: E_peak = %.2f%%" % (ds.ph_sel, E_pr_do_kde*100))
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
Burst sizes
nt_th1 = 50 dplot(ds_fret, hist_size, which='all', add_naa=False) xlim(-0, 250) plt.axvline(nt_th1) Th_nt = np.arange(35, 120) nt_th = np.zeros(Th_nt.size) for i, th in enumerate(Th_nt): ds_nt = ds_fret.select_bursts(select_bursts.size, th1=th) nt_th[i] = (ds_nt.nd[0] + ds_nt.na[0]).mean() - th plt.figure() plot(Th_nt, nt_th) plt.axvline(nt_th1) nt_mean = nt_th[np.where(Th_nt == nt_th1)][0] nt_mean
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
Fret fit Max position of the Kernel Density Estimation (KDE):
E_pr_fret_kde = bext.fit_bursts_kde_peak(ds_fret, bandwidth=bandwidth, weights='size') E_fitter = ds_fret.E_fitter E_fitter.histogram(bins=np.r_[-0.1:1.1:0.03]) E_fitter.fit_histogram(mfit.factory_gaussian(center=0.5)) E_fitter.fit_res[0].params.pretty_print() fig, ax = plt.subplots(1, 2, figsize=(14, 4.5)) mfit.plot_mfit(E_fitter, ax=ax[0]) mfit.plot_mfit(E_fitter, plot_model=False, plot_kde=True, ax=ax[1]) print('%s\nKDE peak %.2f ' % (ds_fret.ph_sel, E_pr_fret_kde*100)) display(E_fitter.params*100)
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
Weighted mean of $E$ of each burst:
ds_fret.fit_E_m(weights='size')
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
Gaussian fit (no weights):
ds_fret.fit_E_generic(fit_fun=bl.gaussian_fit_hist, bins=np.r_[-0.1:1.1:0.03], weights=None)
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
Gaussian fit (using burst size as weights):
ds_fret.fit_E_generic(fit_fun=bl.gaussian_fit_hist, bins=np.r_[-0.1:1.1:0.005], weights='size') E_kde_w = E_fitter.kde_max_pos[0] E_gauss_w = E_fitter.params.loc[0, 'center'] E_gauss_w_sig = E_fitter.params.loc[0, 'sigma'] E_gauss_w_err = float(E_gauss_w_sig/np.sqrt(ds_fret.num_bursts[0])) E_gauss_w_fiterr = E_fitter.fit_res[0].params['center'].stderr E_kde_w, E_gauss_w, E_gauss_w_sig, E_gauss_w_err, E_gauss_w_fiterr
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
Stoichiometry fit Max position of the Kernel Density Estimation (KDE):
S_pr_fret_kde = bext.fit_bursts_kde_peak(ds_fret, burst_data='S', bandwidth=0.03) #weights='size', add_naa=True) S_fitter = ds_fret.S_fitter S_fitter.histogram(bins=np.r_[-0.1:1.1:0.03]) S_fitter.fit_histogram(mfit.factory_gaussian(), center=0.5) fig, ax = plt.subplots(1, 2, figsize=(14, 4.5)) mfit.plot_mfit(S_fitter, ax=ax[0]) mfit.plot_mfit(S_fitter, plot_model=False, plot_kde=True, ax=ax[1]) print('%s\nKDE peak %.2f ' % (ds_fret.ph_sel, S_pr_fret_kde*100)) display(S_fitter.params*100) S_kde = S_fitter.kde_max_pos[0] S_gauss = S_fitter.params.loc[0, 'center'] S_gauss_sig = S_fitter.params.loc[0, 'sigma'] S_gauss_err = float(S_gauss_sig/np.sqrt(ds_fret.num_bursts[0])) S_gauss_fiterr = S_fitter.fit_res[0].params['center'].stderr S_kde, S_gauss, S_gauss_sig, S_gauss_err, S_gauss_fiterr
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
The Maximum likelihood fit for a Gaussian population is the mean:
S = ds_fret.S[0] S_ml_fit = (S.mean(), S.std()) S_ml_fit
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
Computing the weighted mean and weighted standard deviation we get:
weights = bl.fret_fit.get_weights(ds_fret.nd[0], ds_fret.na[0], weights='size', naa=ds_fret.naa[0], gamma=1.) S_mean = np.dot(weights, S)/weights.sum() S_std_dev = np.sqrt( np.dot(weights, (S - S_mean)**2)/weights.sum()) S_wmean_fit = [S_mean, S_std_dev] S_wmean_fit
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
Save data to file
sample = data_id
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
The following string contains the list of variables to be saved. When saving, the order of the variables is preserved.
variables = ('sample n_bursts_all n_bursts_do n_bursts_fret ' 'E_kde_w E_gauss_w E_gauss_w_sig E_gauss_w_err E_gauss_w_fiterr ' 'S_kde S_gauss S_gauss_sig S_gauss_err S_gauss_fiterr ' 'E_pr_do_kde nt_mean\n')
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
This is just a trick to format the different variables:
variables_csv = variables.replace(' ', ',') fmt_float = '{%s:.6f}' fmt_int = '{%s:d}' fmt_str = '{%s}' fmt_dict = {**{'sample': fmt_str}, **{k: fmt_int for k in variables.split() if k.startswith('n_bursts')}} var_dict = {name: eval(name) for name in variables.split()} var_fmt = ', '.join([fmt_dict.get(name, fmt_float) % name for name in variables.split()]) + '\n' data_str = var_fmt.format(**var_dict) print(variables_csv) print(data_str) # NOTE: The file name should be the notebook name but with .csv extension with open('results/usALEX-5samples-E-corrected-all-ph.csv', 'a') as f: f.seek(0, 2) if f.tell() == 0: f.write(variables_csv) f.write(data_str)
out_notebooks/usALEX-5samples-E-corrected-all-ph-out-12d.ipynb
tritemio/multispot_paper
mit
Data folder:
data_dir = './data/singlespot/'
out_notebooks/usALEX-5samples-PR-raw-dir_ex_aa-fit-out-AexAem-17d.ipynb
tritemio/multispot_paper
mit
Check that the folder exists:
import os data_dir = os.path.abspath(data_dir) + '/' assert os.path.exists(data_dir), "Path '%s' does not exist." % data_dir
out_notebooks/usALEX-5samples-PR-raw-dir_ex_aa-fit-out-AexAem-17d.ipynb
tritemio/multispot_paper
mit
List of data files in data_dir:
from glob import glob file_list = sorted(f for f in glob(data_dir + '*.hdf5') if '_BKG' not in f) file_list ## Selection for POLIMI 2012-12-6 dataset # file_list.pop(2) # file_list = file_list[1:-2] # display(file_list) # labels = ['22d', '27d', '17d', '12d', '7d'] ## Selection for P.E. 2012-12-6 dataset # file_list.pop(1) # file_list = file_list[:-1] # display(file_list) # labels = ['22d', '27d', '17d', '12d', '7d'] ## Selection for POLIMI 2012-11-26 datatset labels = ['17d', '27d', '7d', '12d', '22d'] files_dict = {lab: fname for lab, fname in zip(labels, file_list)} files_dict ph_sel_map = {'all-ph': Ph_sel('all'), 'AexAem': Ph_sel(Aex='Aem')} ph_sel = ph_sel_map[ph_sel_name] data_id, ph_sel_name
out_notebooks/usALEX-5samples-PR-raw-dir_ex_aa-fit-out-AexAem-17d.ipynb
tritemio/multispot_paper
mit
Laser alternation selection At this point we have only the timestamps and the detector numbers:
d.ph_times_t, d.det_t
out_notebooks/usALEX-5samples-PR-raw-dir_ex_aa-fit-out-AexAem-17d.ipynb
tritemio/multispot_paper
mit
If the plot looks good we can apply the parameters with:
loader.alex_apply_period(d)
out_notebooks/usALEX-5samples-PR-raw-dir_ex_aa-fit-out-AexAem-17d.ipynb
tritemio/multispot_paper
mit
Burst search and selection
from mpl_toolkits.axes_grid1 import AxesGrid import lmfit print('lmfit version:', lmfit.__version__) assert d.dir_ex == 0 assert d.leakage == 0 d.burst_search(m=10, F=6, ph_sel=ph_sel) print(d.ph_sel, d.num_bursts) ds_sa = d.select_bursts(select_bursts.naa, th1=30) ds_sa.num_bursts
out_notebooks/usALEX-5samples-PR-raw-dir_ex_aa-fit-out-AexAem-17d.ipynb
tritemio/multispot_paper
mit
Preliminary selection and plots
mask = (d.naa[0] - np.abs(d.na[0] + d.nd[0])) > 30 ds_saw = d.select_bursts_mask_apply([mask]) ds_sas0 = ds_sa.select_bursts(select_bursts.S, S2=0.10) ds_sas = ds_sa.select_bursts(select_bursts.S, S2=0.15) ds_sas2 = ds_sa.select_bursts(select_bursts.S, S2=0.20) ds_sas3 = ds_sa.select_bursts(select_bursts.S, S2=0.25) ds_st = d.select_bursts(select_bursts.size, add_naa=True, th1=30) ds_sas.num_bursts dx = ds_sas0 size = dx.na[0] + dx.nd[0] s_hist, s_bins = np.histogram(size, bins=np.r_[-15 : 25 : 1], density=True) s_ax = s_bins[:-1] + 0.5*(s_bins[1] - s_bins[0]) plot(s_ax, s_hist, '-o', alpha=0.5) dx = ds_sas size = dx.na[0] + dx.nd[0] s_hist, s_bins = np.histogram(size, bins=np.r_[-15 : 25 : 1], density=True) s_ax = s_bins[:-1] + 0.5*(s_bins[1] - s_bins[0]) plot(s_ax, s_hist, '-o', alpha=0.5) dx = ds_sas2 size = dx.na[0] + dx.nd[0] s_hist, s_bins = np.histogram(size, bins=np.r_[-15 : 25 : 1], density=True) s_ax = s_bins[:-1] + 0.5*(s_bins[1] - s_bins[0]) plot(s_ax, s_hist, '-o', alpha=0.5) dx = ds_sas3 size = dx.na[0] + dx.nd[0] s_hist, s_bins = np.histogram(size, bins=np.r_[-15 : 25 : 1], density=True) s_ax = s_bins[:-1] + 0.5*(s_bins[1] - s_bins[0]) plot(s_ax, s_hist, '-o', alpha=0.5) plt.title('(nd + na) for A-only population using different S cutoff'); dx = ds_sa alex_jointplot(dx); dplot(ds_sa, hist_S)
out_notebooks/usALEX-5samples-PR-raw-dir_ex_aa-fit-out-AexAem-17d.ipynb
tritemio/multispot_paper
mit
A-direct excitation fitting To extract the A-direct excitation coefficient we need to fit the S values for the A-only population. The S value for the A-only population is fitted with different methods: - Histogram git with 2 Gaussians or with 2 asymmetric Gaussians (an asymmetric Gaussian has right- and left-side of the peak decreasing according to different sigmas). - KDE maximum In the following we apply these methods using different selection or weighting schemes to reduce amount of FRET population and make fitting of the A-only population easier. Even selection Here A-only and FRET population are evenly selected.
dx = ds_sa bin_width = 0.03 bandwidth = 0.03 bins = np.r_[-0.2 : 1 : bin_width] x_kde = np.arange(bins.min(), bins.max(), 0.0002) ## Weights weights = None ## Histogram fit fitter_g = mfit.MultiFitter(dx.S) fitter_g.histogram(bins=np.r_[-0.2 : 1.2 : bandwidth]) fitter_g.fit_histogram(model = mfit.factory_two_gaussians(p1_center=0.1, p2_center=0.4)) S_hist_orig = fitter_g.hist_pdf S_2peaks = fitter_g.params.loc[0, 'p1_center'] dir_ex_S2p = S_2peaks/(1 - S_2peaks) print('Fitted direct excitation (na/naa) [2-Gauss]:', dir_ex_S2p) ## KDE fitter_g.calc_kde(bandwidth=bandwidth) fitter_g.find_kde_max(x_kde, xmin=0, xmax=0.15) S_peak = fitter_g.kde_max_pos[0] dir_ex_S_kde = S_peak/(1 - S_peak) print('Fitted direct excitation (na/naa) [KDE]: ', dir_ex_S_kde) fig, ax = plt.subplots(1, 2, figsize=(14, 4.5)) mfit.plot_mfit(fitter_g, ax=ax[0]) ax[0].set_title('2-Gaussians fit (S_fit = %.2f %%)' % (S_2peaks*100)) mfit.plot_mfit(fitter_g, ax=ax[1], plot_model=False, plot_kde=True) ax[1].set_title('KDE fit (S_fit = %.2f %%)' % (S_peak*100)); ## 2-Asym-Gaussian fitter_ag = mfit.MultiFitter(dx.S) fitter_ag.histogram(bins=np.r_[-0.2 : 1.2 : bandwidth]) fitter_ag.fit_histogram(model = mfit.factory_two_asym_gaussians(p1_center=0.1, p2_center=0.4)) #print(fitter_ag.fit_obj[0].model.fit_report()) S_2peaks_a = fitter_ag.params.loc[0, 'p1_center'] dir_ex_S2pa = S_2peaks_a/(1 - S_2peaks_a) print('Fitted direct excitation (na/naa) [2-Gauss]:', dir_ex_S2pa) fig, ax = plt.subplots(1, 2, figsize=(14, 4.5)) mfit.plot_mfit(fitter_g, ax=ax[0]) ax[0].set_title('2-Gaussians fit (S_fit = %.2f %%)' % (S_2peaks*100)) mfit.plot_mfit(fitter_ag, ax=ax[1]) ax[1].set_title('2-Asym-Gaussians fit (S_fit = %.2f %%)' % (S_2peaks_a*100));
out_notebooks/usALEX-5samples-PR-raw-dir_ex_aa-fit-out-AexAem-17d.ipynb
tritemio/multispot_paper
mit
Zero threshold on nd Select bursts with: $$n_d < 0$$.
dx = ds_sa.select_bursts(select_bursts.nd, th1=-100, th2=0) fitter = bext.bursts_fitter(dx, 'S') fitter.fit_histogram(model = mfit.factory_gaussian(center=0.1)) S_1peaks_th = fitter.params.loc[0, 'center'] dir_ex_S1p = S_1peaks_th/(1 - S_1peaks_th) print('Fitted direct excitation (na/naa) [2-Gauss]:', dir_ex_S1p) mfit.plot_mfit(fitter) plt.xlim(-0.1, 0.6)
out_notebooks/usALEX-5samples-PR-raw-dir_ex_aa-fit-out-AexAem-17d.ipynb
tritemio/multispot_paper
mit
Selection 1 Bursts are weighted using $w = f(S)$, where the function $f(S)$ is a Gaussian fitted to the $S$ histogram of the FRET population.
dx = ds_sa ## Weights weights = 1 - mfit.gaussian(dx.S[0], fitter_g.params.loc[0, 'p2_center'], fitter_g.params.loc[0, 'p2_sigma']) weights[dx.S[0] >= fitter_g.params.loc[0, 'p2_center']] = 0 ## Histogram fit fitter_w1 = mfit.MultiFitter(dx.S) fitter_w1.weights = [weights] fitter_w1.histogram(bins=np.r_[-0.2 : 1.2 : bandwidth]) fitter_w1.fit_histogram(model = mfit.factory_two_gaussians(p1_center=0.1, p2_center=0.4)) S_2peaks_w1 = fitter_w1.params.loc[0, 'p1_center'] dir_ex_S2p_w1 = S_2peaks_w1/(1 - S_2peaks_w1) print('Fitted direct excitation (na/naa) [2-Gauss]:', dir_ex_S2p_w1) ## KDE fitter_w1.calc_kde(bandwidth=bandwidth) fitter_w1.find_kde_max(x_kde, xmin=0, xmax=0.15) S_peak_w1 = fitter_w1.kde_max_pos[0] dir_ex_S_kde_w1 = S_peak_w1/(1 - S_peak_w1) print('Fitted direct excitation (na/naa) [KDE]: ', dir_ex_S_kde_w1) def plot_weights(x, weights, ax): ax2 = ax.twinx() x_sort = x.argsort() ax2.plot(x[x_sort], weights[x_sort], color='k', lw=4, alpha=0.4) ax2.set_ylabel('Weights'); fig, ax = plt.subplots(1, 2, figsize=(14, 4.5)) mfit.plot_mfit(fitter_w1, ax=ax[0]) mfit.plot_mfit(fitter_g, ax=ax[0], plot_model=False, plot_kde=False) plot_weights(dx.S[0], weights, ax=ax[0]) ax[0].set_title('2-Gaussians fit (S_fit = %.2f %%)' % (S_2peaks_w1*100)) mfit.plot_mfit(fitter_w1, ax=ax[1], plot_model=False, plot_kde=True) mfit.plot_mfit(fitter_g, ax=ax[1], plot_model=False, plot_kde=False) plot_weights(dx.S[0], weights, ax=ax[1]) ax[1].set_title('KDE fit (S_fit = %.2f %%)' % (S_peak_w1*100));
out_notebooks/usALEX-5samples-PR-raw-dir_ex_aa-fit-out-AexAem-17d.ipynb
tritemio/multispot_paper
mit
Selection 2 Bursts are here weighted using weights $w$: $$w = n_{aa} - |n_a + n_d|$$
## Weights sizes = dx.nd[0] + dx.na[0] #- dir_ex_S_kde_w3*dx.naa[0] weights = dx.naa[0] - abs(sizes) weights[weights < 0] = 0 ## Histogram fitter_w4 = mfit.MultiFitter(dx.S) fitter_w4.weights = [weights] fitter_w4.histogram(bins=np.r_[-0.2 : 1.2 : bandwidth]) fitter_w4.fit_histogram(model = mfit.factory_two_gaussians(p1_center=0.1, p2_center=0.4)) S_2peaks_w4 = fitter_w4.params.loc[0, 'p1_center'] dir_ex_S2p_w4 = S_2peaks_w4/(1 - S_2peaks_w4) print('Fitted direct excitation (na/naa) [2-Gauss]:', dir_ex_S2p_w4) ## KDE fitter_w4.calc_kde(bandwidth=bandwidth) fitter_w4.find_kde_max(x_kde, xmin=0, xmax=0.15) S_peak_w4 = fitter_w4.kde_max_pos[0] dir_ex_S_kde_w4 = S_peak_w4/(1 - S_peak_w4) print('Fitted direct excitation (na/naa) [KDE]: ', dir_ex_S_kde_w4) fig, ax = plt.subplots(1, 2, figsize=(14, 4.5)) mfit.plot_mfit(fitter_w4, ax=ax[0]) mfit.plot_mfit(fitter_g, ax=ax[0], plot_model=False, plot_kde=False) #plot_weights(dx.S[0], weights, ax=ax[0]) ax[0].set_title('2-Gaussians fit (S_fit = %.2f %%)' % (S_2peaks_w4*100)) mfit.plot_mfit(fitter_w4, ax=ax[1], plot_model=False, plot_kde=True) mfit.plot_mfit(fitter_g, ax=ax[1], plot_model=False, plot_kde=False) #plot_weights(dx.S[0], weights, ax=ax[1]) ax[1].set_title('KDE fit (S_fit = %.2f %%)' % (S_peak_w4*100));
out_notebooks/usALEX-5samples-PR-raw-dir_ex_aa-fit-out-AexAem-17d.ipynb
tritemio/multispot_paper
mit
Selection 3 Bursts are here selected according to: $$n_{aa} - |n_a + n_d| > 30$$
mask = (d.naa[0] - np.abs(d.na[0] + d.nd[0])) > 30 ds_saw = d.select_bursts_mask_apply([mask]) print(ds_saw.num_bursts) dx = ds_saw ## Weights weights = None ## 2-Gaussians fitter_w5 = mfit.MultiFitter(dx.S) fitter_w5.histogram(bins=np.r_[-0.2 : 1.2 : bandwidth]) fitter_w5.fit_histogram(model = mfit.factory_two_gaussians(p1_center=0.1, p2_center=0.4)) S_2peaks_w5 = fitter_w5.params.loc[0, 'p1_center'] dir_ex_S2p_w5 = S_2peaks_w5/(1 - S_2peaks_w5) print('Fitted direct excitation (na/naa) [2-Gauss]:', dir_ex_S2p_w5) ## KDE fitter_w5.calc_kde(bandwidth=bandwidth) fitter_w5.find_kde_max(x_kde, xmin=0, xmax=0.15) S_peak_w5 = fitter_w5.kde_max_pos[0] S_2peaks_w5_fiterr = fitter_w5.fit_res[0].params['p1_center'].stderr dir_ex_S_kde_w5 = S_peak_w5/(1 - S_peak_w5) print('Fitted direct excitation (na/naa) [KDE]: ', dir_ex_S_kde_w5) ## 2-Asym-Gaussians fitter_w5a = mfit.MultiFitter(dx.S) fitter_w5a.histogram(bins=np.r_[-0.2 : 1.2 : bandwidth]) fitter_w5a.fit_histogram(model = mfit.factory_two_asym_gaussians(p1_center=0.05, p2_center=0.3)) S_2peaks_w5a = fitter_w5a.params.loc[0, 'p1_center'] dir_ex_S2p_w5a = S_2peaks_w5a/(1 - S_2peaks_w5a) #print(fitter_w5a.fit_obj[0].model.fit_report(min_correl=0.5)) print('Fitted direct excitation (na/naa) [2-Asym-Gauss]:', dir_ex_S2p_w5a) fig, ax = plt.subplots(1, 3, figsize=(19, 4.5)) mfit.plot_mfit(fitter_w5, ax=ax[0]) mfit.plot_mfit(fitter_g, ax=ax[0], plot_model=False, plot_kde=False) ax[0].set_title('2-Gaussians fit (S_fit = %.2f %%)' % (S_2peaks_w5*100)) mfit.plot_mfit(fitter_w5, ax=ax[1], plot_model=False, plot_kde=True) mfit.plot_mfit(fitter_g, ax=ax[1], plot_model=False, plot_kde=False) ax[1].set_title('KDE fit (S_fit = %.2f %%)' % (S_peak_w5*100)); mfit.plot_mfit(fitter_w5a, ax=ax[2]) mfit.plot_mfit(fitter_g, ax=ax[2], plot_model=False, plot_kde=False) ax[2].set_title('2-Asym-Gaussians fit (S_fit = %.2f %%)' % (S_2peaks_w5a*100));
out_notebooks/usALEX-5samples-PR-raw-dir_ex_aa-fit-out-AexAem-17d.ipynb
tritemio/multispot_paper
mit
Save data to file
sample = data_id n_bursts_aa = ds_sas.num_bursts[0]
out_notebooks/usALEX-5samples-PR-raw-dir_ex_aa-fit-out-AexAem-17d.ipynb
tritemio/multispot_paper
mit
The following string contains the list of variables to be saved. When saving, the order of the variables is preserved.
variables = ('sample n_bursts_aa dir_ex_S1p dir_ex_S_kde dir_ex_S2p dir_ex_S2pa ' 'dir_ex_S2p_w1 dir_ex_S_kde_w1 dir_ex_S_kde_w4 dir_ex_S_kde_w5 dir_ex_S2p_w5 dir_ex_S2p_w5a ' 'S_2peaks_w5 S_2peaks_w5_fiterr\n')
out_notebooks/usALEX-5samples-PR-raw-dir_ex_aa-fit-out-AexAem-17d.ipynb
tritemio/multispot_paper
mit
This is just a trick to format the different variables:
variables_csv = variables.replace(' ', ',') fmt_float = '{%s:.6f}' fmt_int = '{%s:d}' fmt_str = '{%s}' fmt_dict = {**{'sample': fmt_str}, **{k: fmt_int for k in variables.split() if k.startswith('n_bursts')}} var_dict = {name: eval(name) for name in variables.split()} var_fmt = ', '.join([fmt_dict.get(name, fmt_float) % name for name in variables.split()]) + '\n' data_str = var_fmt.format(**var_dict) print(variables_csv) print(data_str) # NOTE: The file name should be the notebook name but with .csv extension with open('results/usALEX-5samples-PR-raw-dir_ex_aa-fit-%s.csv' % ph_sel_name, 'a') as f: f.seek(0, 2) if f.tell() == 0: f.write(variables_csv) f.write(data_str)
out_notebooks/usALEX-5samples-PR-raw-dir_ex_aa-fit-out-AexAem-17d.ipynb
tritemio/multispot_paper
mit
1. Get Arxiv data about machine learning Write a APi querier and extract papers with the terms machine learning or artificial intelligence. Get 2000 results... and play nice!
class Arxiv_querier(): ''' This class takes as an input a query and the number of results, and returns all the parsed results. Includes routines to deal with multiple pages of results. ''' def __init__(self,base_url="http://export.arxiv.org/api/query?"): ''' Initialise ''' self.base_url = base_url def query(self,query_string,max_results=100,wait_time=3): ''' Query the base url ''' #Attribute query string #Load base URL base_url = self.base_url #Prepare query string processed_query = re.sub(' ','+',query_string) self.query_string="_".join(query_string.split(" ")) start=0 pages = 0 #Run the query and store results for as long as the number of results is bigger than the max results keep_running = True result_store = [] while keep_running==True: pages +=1 print(pages) #Query url (NB the start arg, which will change as we go through different #pages) query_url = base_url+'search_query=all:{q}&start={s}&max_results={max_res}'.format( q=processed_query,s=start,max_res=max_results) #Download source = requests.get(query_url) #Parse the xml and get the entries (papers) parsed = feedparser.parse(source.content) #Extract entries entries = parsed['entries'] #If the number of entries is bigger than the maximum number of results #this means we need to go to another page. We do that by offseting the #start with max results result_store.append(entries) if len(entries)==max_results: start+=max_results #If we have less than max results this means we have run out of #results and we toggle the keep_running switch off. if len(entries)<max_results: keep_running=False time.sleep(wait_time) #Save results in a flat list self.entry_results = [x for el in result_store for x in el] def extract_data(self): ''' Here we extract data from the entries ''' #Load entries entries = self.entry_results #Create df output = pd.concat([pd.DataFrame({ 'query':self.query_string, 'id':x['id'], 'link':x['link'], 'title':x['title'], 'authors':", ".join([el['name'] for el in x['authors']]), 'summary':x['summary'], 'updated':x['updated'], 'published':x['published'], 'category':x['arxiv_primary_category']['term'], 'pdf':str([el['href'] for el in x['links'] if el['type']=='application/pdf'][0] )},index=[0]) for x in entries]).reset_index(drop=True) output['year_published'] = [x.split("-")[0] for x in output['published']] self.output_df = output query_terms = ['artificial intelligence','machine learning','deep learning'] #There are some inconsistencies in the number of results so we run the query three times for each #term and remove duplicated results def extract_arxiv_data(term,max_results=1000,wait_time=10, tests=3): ''' This function initialises the Arxiv_querier class, extracts the data and outputs it ''' print(term) collected = [] #We collect the data thrice for i in np.arange(tests): print('run'+ ' ' +str(i)) initialised = Arxiv_querier() initialised.query(term,max_results,wait_time) initialised.extract_data() out = initialised.output_df collected.append(out) #We concatenate the dfs and remove the duplicates. output = pd.concat(collected) output_no_dupes = output.drop_duplicates('id') #Return both return([output,output_no_dupes]) arxiv_ai_results_three = [extract_arxiv_data(term=q) for q in query_terms] all_papers = pd.concat([x[1] for x in arxiv_ai_results_three]).drop_duplicates('id').reset_index(drop=True) print(all_papers.shape) all_papers.head() all_papers.to_csv(int_data+'/{today}_ai_papers.csv'.format(today=today_str),index=False)
notebooks/ml_topic_analysis_exploration.ipynb
Juan-Mateos/coll_int_ai_case
mit
2. Some exploratory analysis
from nltk.corpus import stopwords from nltk.tokenize import word_tokenize, sent_tokenize, RegexpTokenizer, PunktSentenceTokenizer from nltk.stem import WordNetLemmatizer, SnowballStemmer, PorterStemmer import scipy import ast import string as st from bs4 import BeautifulSoup import gensim from gensim.models.coherencemodel import CoherenceModel from sklearn.feature_extraction.text import TfidfVectorizer from itertools import product stopwords_c = stopwords.words('english') stemmer = PorterStemmer() lemmatizer= WordNetLemmatizer() #Read papers all_papers = pd.read_csv(int_data+'/19_8_2017_ai_papers.csv'.format(today=today_str)) #Let's begin by looking at years #When where they published? #Year distribution year_pubs = all_papers['year_published'].value_counts() year_pubs.index = [int(x) for x in year_pubs.index] fig,ax = plt.subplots(figsize=(10,5)) year_pubs_sorted = year_pubs[sorted(year_pubs.index)] year_pubs_subset = year_pubs_sorted[year_pubs_sorted.index>1991] ax.plot(np.arange(1993,2018),year_pubs_subset.cumsum(),color='red') ax.bar(np.arange(1993,2018),year_pubs_subset) ax.hlines(xmin=1993,xmax=2017,y=[10000,20000,30000,40000],colors='green',linestyles='dashed',alpha=0.7) ax.set_title("Papers on AI, ML and DL, total per year (bar) and cumulative (red)",size=14) #What are the categories of the papers? Are we capturing what we think we are capturing #Top 20 all_papers['category'].value_counts()[:20]
notebooks/ml_topic_analysis_exploration.ipynb
Juan-Mateos/coll_int_ai_case
mit
See <a href='https://arxiv.org/help/api/user-manual'>here</a> for abbreviations of categories. In a nutshell, AI is AI, LG is 'Learning', CV is 'Computer Vision', 'CL' is 'computation and language' and NE is 'Neural and Evolutionary computing'. SL.ML is kind of self-explanatory. We seem to be picking up the main things
#NB do we want to remove hyphens? punct = re.sub('-','',st.punctuation) def comp_sentence(sentence): ''' Takes a sentence and pre-processes it. The output is the sentence as a bag of words ''' #Remove line breaks and hyphens sentence = re.sub('\n',' ',sentence) sentence = re.sub('-',' ',sentence) #Lowercase and tokenise text_lowered = [x.lower() for x in sentence.split(" ")] #Remove signs and digits text_no_signs_digits = ["".join([x for x in el if x not in punct+st.digits]) for el in text_lowered] #Remove stop words, single letters text_stopped = [w for w in text_no_signs_digits if w not in stopwords_c and len(w)>1] #Stem text_lemmatised = [lemmatizer.lemmatize(w) for w in text_stopped] #Output return(text_lemmatised) #Process text clean_corpus = [comp_sentence(x) for x in all_papers['summary']] #We remove rate words word_freqs = pd.Series([x for el in clean_corpus for x in el]).value_counts() word_freqs[:30] rare_words = word_freqs.index[word_freqs<=2] rare_words[:10]
notebooks/ml_topic_analysis_exploration.ipynb
Juan-Mateos/coll_int_ai_case
mit
Lots of the rare words seem to be typos and so forth. We remove them
#Removing rare words clean_corpus_no_rare = [[x for x in el if x not in rare_words] for el in clean_corpus]
notebooks/ml_topic_analysis_exploration.ipynb
Juan-Mateos/coll_int_ai_case
mit
2 NLP (topic modelling & word embeddings)
#Identify 2-grams (frequent in science!) bigram_transformer = gensim.models.Phrases(clean_corpus_no_rare) #Train the model on the corpus #Let's do a bit of grid search #model = gensim.models.Word2Vec(bigram_transformer[clean_corpus], size=360, window=15, min_count=2, iter=20) model.most_similar('ai_safety') model.most_similar('complexity') model.most_similar('github') #Create 3 different dictionaries and bows depending on word sizes def remove_words_below_threshold(corpus,threshold): ''' Takes a list of terms and removes any which are below a threshold of occurrences ''' #Produce token frequencies token_frequencies = pd.Series([x for el in corpus for x in el]).value_counts() #Identify tokens to drop (below a threshold) tokens_to_drop = token_frequencies.index[token_frequencies<=threshold] #Processed corpus processed_corpus = [[x for x in el if x not in tokens_to_drop] for el in corpus] #Dictionary dictionary = gensim.corpora.Dictionary(processed_corpus) corpus_bow = [dictionary.doc2bow(x) for x in processed_corpus] return([dictionary,corpus_bow,processed_corpus]) #Initial model run to see what comes out. #Transform corpus to bigrams transformed_corpus = bigram_transformer[clean_corpus] corpora_to_process = {str(x):remove_words_below_threshold(transformed_corpus,x) for x in [1,2,5,10]} #Need to turn this into a function. #Topic modelling #Parameters for Grid search. lda_params = list(product([100,200,300],[2,5])) #Model container lda_models = [] for x in lda_params: #Print stage print('{x}_{y}'.format(x=x[0],y=x[1])) #Load corpus and dict dictionary = corpora_to_process[str(x[1])][0] corpus_bow = corpora_to_process[str(x[1])][1] corpus = corpora_to_process[str(x[1])][2] print('training') #Train model mod = gensim.models.LdaModel(corpus_bow,num_topics=x[0],id2word=dictionary, passes=10,iterations=50) print('coherence') #Extract coherence cm = CoherenceModel(mod,texts=corpus, dictionary=dictionary,coherence='u_mass') #Get value try: coherence_value = cm.get_coherence() except: print('coherence_error') coherence_value='error' lda_models.append([x,mod,[coherence_value,cm]]) with open(mod_path+'/{t}_ai_topic_models.p'.format(t=today_str),'wb') as outfile: pickle.dump(lda_models,outfile) #Visualiase model performance model_eval = pd.DataFrame([[x[0][0],x[0][1],x[2][0]] for x in lda_models],columns=['topics','word_lim','coherence']) fig,ax = plt.subplots(figsize=(10,5)) cols = ['red','green','blue'] legs = [] for num,x in enumerate(set(model_eval['word_lim'])): subset = model_eval.loc[[z == x for z in model_eval['word_lim']],:] ax.plot(subset.loc[:,'topics'],subset.loc[:,'coherence'],color=cols[num-1]) legs.append([cols[num-1],x]) ax.legend(labels=[x[1] for x in legs],title='Min word count') ax.set_title('Model performance with different parameters') with open(mod_path+'/19_8_2017_ai_topic_models.p','rb') as infile: lda_models = pickle.load(infile) check_model= lda_models[1][1] #Explore topics via LDAvis import pyLDAvis.gensim pyLDAvis.enable_notebook() pyLDAvis.gensim.prepare( #Insert best model/corpus/topics here check_model, corpora_to_process[str(5)][1], corpora_to_process[str(5)][0]) #Can we extract the relevant terms for the topics as in Sievert and Shirley in order to name them? #First - create a matrix with top 30 terms per topic top_30_kws = [check_model.get_topic_terms(topicid=n,topn=1000) for n in np.arange(0,100)] #Keyword df where the columns are tokens and the rows are topics top_30_kws_df = pd.concat([pd.DataFrame([x[1] for x in el], index=[x[0] for x in el]) for el in top_30_kws], axis=1).fillna(0).T.reset_index(drop=True) #This is the dictionary selected_dictionary = corpora_to_process[str(5)][0] #Total number of terms in the document total_terms = np.sum([vals for vals in selected_dictionary.dfs.values()]) #Appearances of different terms document_freqs = pd.Series([v for v in selected_dictionary.dfs.values()], index=[k for k in selected_dictionary.dfs.keys()])[top_30_kws_df.columns]/total_terms #Normalise the terms (divide the vector of probabilities of each keywords in each topic by the totals) top_30_kws_normalised = top_30_kws_df.apply(lambda x: x/document_freqs,axis=0) #Now we want to extract, for each topic, the relevance score. def relevance_score(prob_in_topic,prob_in_corpus,id2word_lookup,lambda_par = 0.6): ''' Combines the probabilities using the definition in Sievert and Shirley and returns the top 5 named #terms for each topic ''' #Create dataframe combined = pd.concat([prob_in_topic,prob_in_corpus],axis=1) combined.columns=['prob_in_topic','prob_in_corpus'] #Create relevance metric combined['relevance'] = lambda_par*combined['prob_in_topic'] + (1-lambda_par)*combined['prob_in_corpus'] #Top words top_ids = list(combined.sort_values('relevance',ascending=False).index[:5]) #Top words top_words = "_".join([id2word_lookup[this_id] for this_id in top_ids]) return(top_words) relevance_scores = [relevance_score(top_30_kws_df.iloc[n,:], top_30_kws_normalised.iloc[n,:], dictionary.id2token,lambda_par=0.6) for n in np.arange(len(top_30_kws_df))] %%time #Create a df with the topic predictions. paper_preds = check_model[corpora_to_process[str(5)][1]] paper_topics_df = pd.concat([pd.DataFrame([x[1] for x in el],index=[x[0] for x in el]) for el in paper_preds], axis=1).T #Replace NAs with zeros and drop pointless index paper_topics_df.fillna(value=0,inplace=True) paper_topics_df.reset_index(drop=True,inplace=True) paper_topics_df.columns = relevance_scores paper_topics_df.to_csv(int_data+'/{t}_paper_topic_mix.csv'.format(t=today_str),index=False) #paper_topics_df = pd.read_csv(int_data+'/{t}_paper_topic_mix.csv') #Quick test of Deep learning papers #These are papers with a topic that seems to capture deep learning dl_papers = [x>0.05 for x in paper_topics_df['network_training_model_deep_deep_learning']] dl_papers_metadata = pd.concat([pd.Series(dl_papers),all_papers],axis=1) paper_frequencies = pd.crosstab(dl_papers_metadata.year_published,dl_papers_metadata[0]) paper_frequencies.columns=['no_dl','dl'] fig,ax = plt.subplots(figsize=(10,5)) paper_frequencies.plot.bar(stacked=True,ax=ax) ax.set_title('Number of papers in the DL \'topic\'') ax.legend(labels=['Not ANN/DL related','NN/DL topic >0.05'])
notebooks/ml_topic_analysis_exploration.ipynb
Juan-Mateos/coll_int_ai_case
mit
Some of this is interesting. Doesn't seem to be picking up the policy related terms (safety, discrimination) Next stages - focus on policy related terms. Can we look for papers in keyword dictionaries identified through the word embeddings? Obtain Google Scholar data
#How many authors are there in the data? Can we collect all their institutions from Google Scholar paper_authors = pd.Series([x for el in all_papers['authors'] for x in el.split(", ")]) paper_authors_unique = paper_authors.drop_duplicates() len(paper_authors_unique)
notebooks/ml_topic_analysis_exploration.ipynb
Juan-Mateos/coll_int_ai_case
mit
We have 68,000 authors. It might take a while to get their data from Google Scholar
#Top authors and frequencies authors_freq = paper_authors.value_counts() fig,ax=plt.subplots(figsize=(10,3)) ax.hist(authors_freq,bins=30) ax.set_title('Distribution of publications') #Pretty skewed distribution! print(authors_freq.describe()) np.sum(authors_freq>2)
notebooks/ml_topic_analysis_exploration.ipynb
Juan-Mateos/coll_int_ai_case
mit
Less than 10,000 authors with 3+ papers in the data
get_scholar_data( %%time #Test run import scholarly @ratelim.patient(max_calls=30,time_interval=60) def get_scholar_data(scholarly_object): '''''' try: scholarly_object = next(scholarly_object) metadata = {} metadata['name']=scholarly_object.name metadata['affiliation'] = scholarly_object.affiliation metadata['interests'] = scholarly_object.interests return(metadata) except: return('nothing') #Extract information from each query (it is a generator) #Get data #ml_author_gscholar=[] for num,x in enumerate(paper_authors_unique[1484:]): if num % 100 == 0: print(str(num)+":"+x) result = get_scholar_data(scholarly.search_author(x)) ml_author_gscholar.append(result) len(ml_author_gscholar)
notebooks/ml_topic_analysis_exploration.ipynb
Juan-Mateos/coll_int_ai_case
mit
1. General Mixture Models pomegranate has a very efficient implementation of mixture models, particularly Gaussian mixture models. Lets take a look at how fast pomegranate is versus sklearn, and then see how much faster parallelization can get it to be.
n, d, k = 1000000, 5, 3 X, y = create_dataset(n, d, k) print "sklearn GMM" %timeit GaussianMixture(n_components=k, covariance_type='full', max_iter=15, tol=1e-10).fit(X) print print "pomegranate GMM" %timeit GeneralMixtureModel.from_samples(MultivariateGaussianDistribution, k, X, max_iterations=15, stop_threshold=1e-10) print print "pomegranate GMM (4 jobs)" %timeit GeneralMixtureModel.from_samples(MultivariateGaussianDistribution, k, X, n_jobs=4, max_iterations=15, stop_threshold=1e-10)
tutorials/old/Tutorial_7_Parallelization.ipynb
jmschrei/pomegranate
mit
It looks like on a large dataset not only is pomegranate faster than sklearn at performing 15 iterations of EM on 3 million 5 dimensional datapoints with 3 clusters, but the parallelization is able to help in speeding things up. Lets now take a look at the time it takes to make predictions using GMMs. Lets fit the model to a small amount of data, and then predict a larger amount of data drawn from the same underlying distributions.
d, k = 25, 2 X, y = create_dataset(1000, d, k) a = GaussianMixture(k, n_init=1, max_iter=25).fit(X) b = GeneralMixtureModel.from_samples(MultivariateGaussianDistribution, k, X, max_iterations=25) del X, y n = 1000000 X, y = create_dataset(n, d, k) print "sklearn GMM" %timeit -n 1 a.predict_proba(X) print print "pomegranate GMM" %timeit -n 1 b.predict_proba(X) print print "pomegranate GMM (4 jobs)" %timeit -n 1 b.predict_proba(X, n_jobs=4)
tutorials/old/Tutorial_7_Parallelization.ipynb
jmschrei/pomegranate
mit
It looks like pomegranate can be slightly slower than sklearn when using a single processor, but that it can be parallelized to get faster performance. At the same time, predictions at this level happen so quickly (millions per second) that this may not be the most reliable test for parallelization. To ensure that we're getting the exact same results just faster, lets subtract the predictions from each other and make sure that the sum is equal to 0.
print (b.predict_proba(X) - b.predict_proba(X, n_jobs=4)).sum()
tutorials/old/Tutorial_7_Parallelization.ipynb
jmschrei/pomegranate
mit
Great, no difference between the two. Lets now make sure that pomegranate and sklearn are learning basically the same thing. Lets fit both models to some 2 dimensional 2 component data and make sure that they both extract the underlying clusters by plotting them.
d, k = 2, 2 X, y = create_dataset(1000, d, k, alpha=2) a = GaussianMixture(k, n_init=1, max_iter=25).fit(X) b = GeneralMixtureModel.from_samples(MultivariateGaussianDistribution, k, X, max_iterations=25) y1, y2 = a.predict(X), b.predict(X) plt.figure(figsize=(16,6)) plt.subplot(121) plt.title("sklearn clusters", fontsize=14) plt.scatter(X[y1==0, 0], X[y1==0, 1], color='m', edgecolor='m') plt.scatter(X[y1==1, 0], X[y1==1, 1], color='c', edgecolor='c') plt.subplot(122) plt.title("pomegranate clusters", fontsize=14) plt.scatter(X[y2==0, 0], X[y2==0, 1], color='m', edgecolor='m') plt.scatter(X[y2==1, 0], X[y2==1, 1], color='c', edgecolor='c')
tutorials/old/Tutorial_7_Parallelization.ipynb
jmschrei/pomegranate
mit
It looks like we're getting the same basic results for the two. The two algorithms are initialized a bit differently, and so it can be difficult to directly compare the results between them, but it looks like they're getting roughly the same results. 3. Multivariate Gaussian HMM Now let's move on to training a hidden Markov model with multivariate Gaussian emissions with a diagonal covariance matrix. We'll randomly generate some Gaussian distributed numbers and use pomegranate with either one or four threads to fit our model to the data.
X = numpy.random.randn(1000, 500, 50) print "pomegranate Gaussian HMM (1 job)" %timeit -n 1 -r 1 HiddenMarkovModel.from_samples(NormalDistribution, 5, X, max_iterations=5) print print "pomegranate Gaussian HMM (2 jobs)" %timeit -n 1 -r 1 HiddenMarkovModel.from_samples(NormalDistribution, 5, X, max_iterations=5, n_jobs=2) print print "pomegranate Gaussian HMM (2 jobs)" %timeit -n 1 -r 1 HiddenMarkovModel.from_samples(NormalDistribution, 5, X, max_iterations=5, n_jobs=4)
tutorials/old/Tutorial_7_Parallelization.ipynb
jmschrei/pomegranate
mit
All we had to do was pass in the n_jobs parameter to the fit function in order to get a speed improvement. It looks like we're getting a really good speed improvement, as well! This is mostly because the HMM algorithms perform a lot more operations than the other models, and so spend the vast majority of time with the GIL released. You may not notice as strong speedups when using a MultivariateGaussianDistribution because BLAS uses multithreaded operations already internally, even when only one job is specified. Now lets look at the prediction function to make sure the we're getting speedups there as well. You'll have to use a wrapper function to parallelize the predictions for a HMM because it returns an annotated sequence rather than a single value like a classic machine learning model might.
model = HiddenMarkovModel.from_samples(NormalDistribution, 5, X, max_iterations=2, verbose=False) print "pomegranate Gaussian HMM (1 job)" %timeit predict_proba(model, X) print print "pomegranate Gaussian HMM (2 jobs)" %timeit predict_proba(model, X, n_jobs=2)
tutorials/old/Tutorial_7_Parallelization.ipynb
jmschrei/pomegranate
mit
Great, we're getting a really good speedup on that as well! Looks like the parallel processing is more efficient with a bigger, more complex model, than with a simple one. This can make sense, because all inference/training is more complex, and so there is more time with the GIL released compared to with the simpler operations. 4. Mixture of Hidden Markov Models Let's stack another layer onto this model by making it a mixture of these hidden Markov models, instead of a single one. At this point we're sticking a multivariate Gaussian HMM into a mixture and we're going to train this big thing in parallel.
def create_model(mus): n = mus.shape[0] starts = numpy.zeros(n) starts[0] = 1. ends = numpy.zeros(n) ends[-1] = 0.5 transition_matrix = numpy.zeros((n, n)) distributions = [] for i in range(n): transition_matrix[i, i] = 0.5 if i < n - 1: transition_matrix[i, i+1] = 0.5 distribution = IndependentComponentsDistribution([NormalDistribution(mu, 1) for mu in mus[i]]) distributions.append(distribution) model = HiddenMarkovModel.from_matrix(transition_matrix, distributions, starts, ends) return model def create_mixture(mus): hmms = [create_model(mu) for mu in mus] return GeneralMixtureModel(hmms) n, d = 50, 10 mus = [(numpy.random.randn(d, n)*0.2 + numpy.random.randn(n)*2).T for i in range(2)] model = create_mixture(mus) X = numpy.random.randn(400, 150, d) print "pomegranate Mixture of Gaussian HMMs (1 job)" %timeit model.fit(X, max_iterations=5) print model = create_mixture(mus) print "pomegranate Mixture of Gaussian HMMs (2 jobs)" %timeit model.fit(X, max_iterations=5, n_jobs=2)
tutorials/old/Tutorial_7_Parallelization.ipynb
jmschrei/pomegranate
mit
Looks like we're getting a really nice speed improvement when training this complex model. Let's take a look now at the time it takes to do inference with it.
model = create_mixture(mus) print "pomegranate Mixture of Gaussian HMMs (1 job)" %timeit model.predict_proba(X) print model = create_mixture(mus) print "pomegranate Mixture of Gaussian HMMs (2 jobs)" %timeit model.predict_proba(X, n_jobs=2)
tutorials/old/Tutorial_7_Parallelization.ipynb
jmschrei/pomegranate
mit
The inner product of blades in GAlgebra is zero if either operand is a scalar: $$\begin{split}\begin{aligned} {\boldsymbol{A}}{r}{\wedge}{\boldsymbol{B}}{s} &\equiv {\left <{{\boldsymbol{A}}{r}{\boldsymbol{B}}{s}} \right >{r+s}} \ {\boldsymbol{A}}{r}\cdot{\boldsymbol{B}}{s} &\equiv {\left { { \begin{array}{cc} r\mbox{ and }s \ne 0: & {\left <{{\boldsymbol{A}}{r}{\boldsymbol{B}}{s}} \right >{{\left |{r-s}\right |}}} \ r\mbox{ or }s = 0: & 0 \end{array}} \right }} \end{aligned}\end{split}$$ This definition comes from David Hestenes and Garret Sobczyk, “Clifford Algebra to Geometric Calculus,” Kluwer Academic Publishers, 1984. In some other literature, the inner product is defined without the exceptional case for scalar part and the definition above is known as "the modified Hestenes inner product" (this name comes from the source code of GAViewer).
c|a a|c c|A A|c
examples/ipython/inner_product.ipynb
arsenovic/galgebra
bsd-3-clause
$ab=a \wedge b + a \cdot b$ holds for vectors:
a*b a^b a|b (a*b)-(a^b)-(a|b)
examples/ipython/inner_product.ipynb
arsenovic/galgebra
bsd-3-clause
$aA=a \wedge A + a \cdot A$ holds for the products between vectors and multivectors:
a*A a^A a|A (a*A)-(a^A)-(a|A)
examples/ipython/inner_product.ipynb
arsenovic/galgebra
bsd-3-clause
$AB=A \wedge B + A \cdot B$ does NOT hold for the products between multivectors and multivectors:
A*B A|B (A*B)-(A^B)-(A|B) (A<B)+(A|B)+(A>B)-A*B
examples/ipython/inner_product.ipynb
arsenovic/galgebra
bsd-3-clause
Toolkit: Visualization Functions This class will introduce 3 different visualizations that can be used with the two different classification type neural networks and regression neural networks. Confusion Matrix - For any type of classification neural network. ROC Curve - For binary classification. Lift Curve - For regression neural networks. The code used to produce these visualizations is shown here:
%matplotlib inline import matplotlib.pyplot as plt from sklearn.metrics import roc_curve, auc # Plot a confusion matrix. # cm is the confusion matrix, names are the names of the classes. def plot_confusion_matrix(cm, names, title='Confusion matrix', cmap=plt.cm.Blues): plt.imshow(cm, interpolation='nearest', cmap=cmap) plt.title(title) plt.colorbar() tick_marks = np.arange(len(names)) plt.xticks(tick_marks, names, rotation=45) plt.yticks(tick_marks, names) plt.tight_layout() plt.ylabel('True label') plt.xlabel('Predicted label') # Plot an ROC. pred - the predictions, y - the expected output. def plot_roc(pred,y): fpr, tpr, _ = roc_curve(y_test, pred) roc_auc = auc(fpr, tpr) plt.figure() plt.plot(fpr, tpr, label='ROC curve (area = %0.2f)' % roc_auc) plt.plot([0, 1], [0, 1], 'k--') plt.xlim([0.0, 1.0]) plt.ylim([0.0, 1.05]) plt.xlabel('False Positive Rate') plt.ylabel('True Positive Rate') plt.title('Receiver Operating Characteristic (ROC)') plt.legend(loc="lower right") plt.show() # Plot a lift curve. pred - the predictions, y - the expected output. def chart_regression(pred,y): t = pd.DataFrame({'pred' : pred.flatten(), 'y' : y_test.flatten()}) t.sort_values(by=['y'],inplace=True) a = plt.plot(t['y'].tolist(),label='expected') b = plt.plot(t['pred'].tolist(),label='prediction') plt.ylabel('output') plt.legend() plt.show()
t81_558_class4_class_reg.ipynb
jbliss1234/ML
apache-2.0
Binary Classification Binary classification is used to create a model that classifies between only two classes. These two classes are often called "positive" and "negative". Consider the following program that uses the wcbreast_wdbc dataset to classify if a breast tumor is cancerous (malignant) or not (benign). The iris dataset is not binary, because there are three classes (3 types of iris).
import os import pandas as pd from sklearn.cross_validation import train_test_split import tensorflow.contrib.learn as skflow import numpy as np from sklearn import metrics path = "./data/" filename = os.path.join(path,"wcbreast_wdbc.csv") df = pd.read_csv(filename,na_values=['NA','?']) # Encode feature vector df.drop('id',axis=1,inplace=True) encode_numeric_zscore(df,'mean_radius') encode_text_index(df,'mean_texture') encode_text_index(df,'mean_perimeter') encode_text_index(df,'mean_area') encode_text_index(df,'mean_smoothness') encode_text_index(df,'mean_compactness') encode_text_index(df,'mean_concavity') encode_text_index(df,'mean_concave_points') encode_text_index(df,'mean_symmetry') encode_text_index(df,'mean_fractal_dimension') encode_text_index(df,'se_radius') encode_text_index(df,'se_texture') encode_text_index(df,'se_perimeter') encode_text_index(df,'se_area') encode_text_index(df,'se_smoothness') encode_text_index(df,'se_compactness') encode_text_index(df,'se_concavity') encode_text_index(df,'se_concave_points') encode_text_index(df,'se_symmetry') encode_text_index(df,'se_fractal_dimension') encode_text_index(df,'worst_radius') encode_text_index(df,'worst_texture') encode_text_index(df,'worst_perimeter') encode_text_index(df,'worst_area') encode_text_index(df,'worst_smoothness') encode_text_index(df,'worst_compactness') encode_text_index(df,'worst_concavity') encode_text_index(df,'worst_concave_points') encode_text_index(df,'worst_symmetry') encode_text_index(df,'worst_fractal_dimension') diagnosis = encode_text_index(df,'diagnosis') num_classes = len(diagnosis) # Create x & y for training # Create the x-side (feature vectors) of the training x, y = to_xy(df,'diagnosis') # Split into train/test x_train, x_test, y_train, y_test = train_test_split( x, y, test_size=0.25, random_state=42) # Create a deep neural network with 3 hidden layers of 10, 20, 10 classifier = skflow.TensorFlowDNNClassifier(hidden_units=[10, 20, 10], n_classes=num_classes, steps=10000) # Early stopping early_stop = skflow.monitors.ValidationMonitor(x_test, y_test, early_stopping_rounds=200, print_steps=50, n_classes=num_classes) # Fit/train neural network classifier.fit(x_train, y_train, early_stop) # Measure accuracy score = metrics.accuracy_score(y, classifier.predict(x)) print("Final accuracy: {}".format(score))
t81_558_class4_class_reg.ipynb
jbliss1234/ML
apache-2.0
Confusion Matrix The confusion matrix is a common visualization for both binary and larger classification problems. Often a model will have difficulty differentiating between two classes. For example, a neural network might be really good at telling the difference between cats and dogs, but not so good at telling the difference between dogs and wolves. The following code generates a confusion matrix:
import numpy as np from sklearn import svm, datasets from sklearn.cross_validation import train_test_split from sklearn.metrics import confusion_matrix pred = classifier.predict(x_test) # Compute confusion matrix cm = confusion_matrix(y_test, pred) np.set_printoptions(precision=2) print('Confusion matrix, without normalization') print(cm) plt.figure() plot_confusion_matrix(cm, diagnosis) # Normalize the confusion matrix by row (i.e by the number of samples # in each class) cm_normalized = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis] print('Normalized confusion matrix') print(cm_normalized) plt.figure() plot_confusion_matrix(cm_normalized, diagnosis, title='Normalized confusion matrix') plt.show()
t81_558_class4_class_reg.ipynb
jbliss1234/ML
apache-2.0
The above two confusion matrixes show the same network. The bottom (normalized) is the type you will normally see. Notice the two labels. The label "B" means benign (no cancer) and the label "M" means malignant (cancer). The left-right (x) axis are the predictions, the top-bottom) are the expected outcomes. A perfect model (that never makes an error) has a dark blue diagonal that runs from top-left to bottom-right. To read, consider the top-left square. This square indicates "true labeled" of B and also "predicted label" of B. This is good! The prediction matched the truth. The blueness of this box represents how often "B" is classified correct. It is not darkest blue. This is because the square to the right(which is off the perfect diagonal) has some color. This square indicates truth of "B" but prediction of "M". The white square, at the bottom-left, indicates a true of "M" but predicted of "B". The whiteness indicates this rarely happens. Your conclusion from the above chart is that the model sometimes classifies "B" as "M" (a false negative), but never mis-classifis "M" as "B". Always look for the dark diagonal, this is good! ROC Curves ROC curves can be a bit confusing. However, they are very common. It is important to know how to read them. Even their name is confusing. Do not worry about their name, it comes from electrical engineering (EE). Binary classification is common in medical testing. Often you want to diagnose if someone has a disease. This can lead to two types of errors, know as false positives and false negatives: False Positive - Your test (neural network) indicated that the patient had the disease; however, the patient did not have the disease. False Negative - Your test (neural network) indicated that the patient did not have the disease; however, the patient did have the disease. True Positive - Your test (neural network) correctly identified that the patient had the disease. True Negative - Your test (neural network) correctly identified that the patient did not have the disease. Types of errors: Neural networks classify in terms of probbility of it being positive. However, at what probability do you give a positive result? Is the cutoff 50%? 90%? Where you set this cutoff is called the threshold. Anything above the cutoff is positive, anything below is negative. Setting this cutoff allows the model to be more sensative or specific: The following shows a more sensitive cutoff: An ROC curve measures how good a model is regardless of the cutoff. The following shows how to read a ROC chart: The following code shows an ROC chart for the breast cancer neural network. The area under the curve (AUC) is also an important measure. The larger the AUC, the better.
pred = classifier.predict_proba(x_test) pred = pred[:,1] # Only positive cases # print(pred[:,1]) plot_roc(pred,y_test)
t81_558_class4_class_reg.ipynb
jbliss1234/ML
apache-2.0
Classification We've already seen multi-class classification, with the iris dataset. Confusion matrixes work just fine with 3 classes. The following code generates a confusion matrix for iris.
import os import pandas as pd from sklearn.cross_validation import train_test_split import tensorflow.contrib.learn as skflow import numpy as np path = "./data/" filename = os.path.join(path,"iris.csv") df = pd.read_csv(filename,na_values=['NA','?']) # Encode feature vector encode_numeric_zscore(df,'petal_w') encode_numeric_zscore(df,'petal_l') encode_numeric_zscore(df,'sepal_w') encode_numeric_zscore(df,'sepal_l') species = encode_text_index(df,"species") num_classes = len(species) # Create x & y for training # Create the x-side (feature vectors) of the training x, y = to_xy(df,'species') # Split into train/test x_train, x_test, y_train, y_test = train_test_split( x, y, test_size=0.25, random_state=45) # as much as I would like to use 42, it gives a perfect result, and a boring confusion matrix! # Create a deep neural network with 3 hidden layers of 10, 20, 10 classifier = skflow.TensorFlowDNNClassifier(hidden_units=[10, 20, 10], n_classes=num_classes, steps=10000) # Early stopping early_stop = skflow.monitors.ValidationMonitor(x_test, y_test, early_stopping_rounds=200, print_steps=50, n_classes=num_classes) # Fit/train neural network classifier.fit(x_train, y_train, early_stop) import numpy as np from sklearn import svm, datasets from sklearn.cross_validation import train_test_split from sklearn.metrics import confusion_matrix pred = classifier.predict(x_test) # Compute confusion matrix cm = confusion_matrix(y_test, pred) np.set_printoptions(precision=2) print('Confusion matrix, without normalization') print(cm) plt.figure() plot_confusion_matrix(cm, species) # Normalize the confusion matrix by row (i.e by the number of samples # in each class) cm_normalized = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis] print('Normalized confusion matrix') print(cm_normalized) plt.figure() plot_confusion_matrix(cm_normalized, species, title='Normalized confusion matrix') plt.show()
t81_558_class4_class_reg.ipynb
jbliss1234/ML
apache-2.0
See the strong diagonal? Iris is easy. See the light blue near the bottom? Sometimes virginica is confused for versicolor. Regression We've already seen regression with the MPG dataset. Regression uses its own set of visualizations, one of the most common is the lift chart. The following code generates a lift chart.
import tensorflow.contrib.learn as skflow import pandas as pd import os import numpy as np from sklearn import metrics from scipy.stats import zscore path = "./data/" filename_read = os.path.join(path,"auto-mpg.csv") df = pd.read_csv(filename_read,na_values=['NA','?']) # create feature vector missing_median(df, 'horsepower') df.drop('name',1,inplace=True) encode_numeric_zscore(df, 'horsepower') encode_numeric_zscore(df, 'weight') encode_numeric_zscore(df, 'cylinders') encode_numeric_zscore(df, 'displacement') encode_numeric_zscore(df, 'acceleration') encode_text_dummy(df, 'origin') # Encode to a 2D matrix for training x,y = to_xy(df,['mpg']) # Split into train/test x_train, x_test, y_train, y_test = train_test_split( x, y, test_size=0.25, random_state=42) # Create a deep neural network with 3 hidden layers of 50, 25, 10 regressor = skflow.TensorFlowDNNRegressor(hidden_units=[50, 25, 10], steps=5000) # Early stopping early_stop = skflow.monitors.ValidationMonitor(x_test, y_test, early_stopping_rounds=200, print_steps=50) # Fit/train neural network regressor.fit(x_train, y_train, early_stop) pred = regressor.predict(x_test) chart_regression(pred,y_test)
t81_558_class4_class_reg.ipynb
jbliss1234/ML
apache-2.0
Reordering the Callendar-Van Duzen equation we obtain the following $$ AT+BT^2+C(T-100)T^3 =\frac{R(T)}{R_0}-1 \enspace,$$ which we can write in matrix form as $Mx=p$, where $$\begin{bmatrix} T_1 & T_1^2 & (T_1-100)T_1^3 \ T_2 & T_2^2 & (T_2-100)T_2^3 \ T_3 & T_3^2 & (T_3-100)T_3^3\end{bmatrix} \begin{bmatrix} A\ B \ C\end{bmatrix} = \begin{bmatrix} \frac{R(T_1)}{R_0}-1 \ \frac{R(T_2)}{R_0}-1 \ \frac{R(T_3)}{R_0}-1\end{bmatrix} \enspace.$$ Because $M$ is square we can solve by computing $M^{-1}$ directly.
R0=25; M=np.array([[T_exp[0],(T_exp[0])**2,(T_exp[0]-100)*(T_exp[0])**3],[T_exp[1],(T_exp[1])**2,(T_exp[1]-100)*(T_exp[1])**3],[T_exp[2],(T_exp[2])**2,(T_exp[2]-100)*(T_exp[2])**3]]); p=np.array([[(R_exp[0]/R0)-1],[(R_exp[1]/R0)-1],[(R_exp[2]/R0)-1]]); x = np.linalg.solve(M,p) #solve linear equations system np.set_printoptions(precision=3) print('M') print(M) print('\n') print('p') print(p) print('\n') print('x') print(x)
notebooks/Ex_2_3.ipynb
agmarrugo/sensors-actuators
mit
We have found the coeffiecients $A$, $B$, and $C$ necessary to describe the sensor's transfer function. Now we plot it from -200 C a 600 C.
A=x[0];B=x[1];C=x[2]; T_range= np.arange(start = -200, stop = 601, step = 1); R_funT= R0*(1+A[0]*T_range+B[0]*(T_range)**2+C[0]*(T_range-100)*(T_range)**3); plt.plot(T_range,R_funT,T_exp[0],R_exp[0],'ro',T_exp[1],R_exp[1],'ro',T_exp[2],R_exp[2],'ro'); plt.ylabel('Sensor resistance [Ohm]') plt.xlabel('Temperature [C]') plt.show()
notebooks/Ex_2_3.ipynb
agmarrugo/sensors-actuators
mit
Reddy Mikks model Given the following variables: $\begin{aligned} x_1 = \textrm{Tons of exterior paint produced daily} \newline x_2 = \textrm{Tons of interior paint produced daily} \end{aligned}$ and knowing that we want to maximize the profit, where \$5000 is the profit from exterior paint and \$4000 is the profit from a ton of interior paint, the Reddy Mikks model is: $$\textrm{Maximize } z = 5x_1 + 4x_2$$ subject to $$6x_1 + 4x_2 \le 24$$ $$x_1 + 2x_2 \le 6$$ $$-x_1 + x_2 \le 1$$ $$x_2 \le 2$$ $$x_1, x_2 \ge 0$$
reddymikks = pywraplp.Solver('Reddy_Mikks', pywraplp.Solver.GLOP_LINEAR_PROGRAMMING) x1 = reddymikks.NumVar(0, reddymikks.infinity(), 'x1') x2 = reddymikks.NumVar(0, reddymikks.infinity(), 'x2') reddymikks.Add(6*x1 + 4*x2 <= 24) reddymikks.Add(x1 + 2*x2 <= 6) reddymikks.Add(-x1 + x2 <= 1) reddymikks.Add(x2 <= 2) profit = reddymikks.Objective() profit.SetCoefficient(x1, 5) profit.SetCoefficient(x2, 4) profit.SetMaximization() status = reddymikks.Solve() if status not in [reddymikks.OPTIMAL, reddymikks.FEASIBLE]: raise Exception('No feasible solution found') print("The company should produce",round(x1.solution_value(),2),"tons of exterior paint") print("The company should produce",round(x2.solution_value(),2),"tons of interior paint") print("The optimal profit is", profit.Value(), 'thousand USD')
Linear Programming with OR-Tools.ipynb
rayjustinhuang/DataAnalysisandMachineLearning
mit
More simple problems A company that operates 10 hours a day manufactures two products on three sequential processes. The following data characterizes the problem:
import pandas as pd problemdata = pd.DataFrame({'Process 1': [10, 5], 'Process 2':[6, 20], 'Process 3':[8, 10], 'Unit profit':[20, 30]}) problemdata.index = ['Product 1', 'Product 2'] problemdata
Linear Programming with OR-Tools.ipynb
rayjustinhuang/DataAnalysisandMachineLearning
mit
Where there are 10 hours a day dedicated to production. Process times are given in minutes per unit while profit is given in USD. The optimal mix of the two products would be characterized by the following model: $\begin{aligned} x_1 = \textrm{Units of product 1} \newline x_2 = \textrm{Units of product 2} \end{aligned}$ $$\textrm{Maximize } z = 20x_1 + 30x_2$$ subject to $$\begin{array}{rcl} 10x_1 + 5x_2 \le 600 \newline 6x_1 + 20x_2 \le 600 \newline 8x_1 + 10x_2 \le 600 \newline x_1, x_2 \ge 0 \end{array}$$ (we will assume that continuous solution values are acceptable for this problem)
simpleprod = pywraplp.Solver('Simple_Production', pywraplp.Solver.GLOP_LINEAR_PROGRAMMING) x1 = simpleprod.NumVar(0, simpleprod.infinity(), 'x1') x2 = simpleprod.NumVar(0, simpleprod.infinity(), 'x2') for i in problemdata.columns[:-1]: simpleprod.Add(problemdata.loc[problemdata.index[0], i]*x1 + problemdata.loc[problemdata.index[1], i]*x2 <= 600) profit = simpleprod.Objective() profit.SetCoefficient(x1, 20) profit.SetCoefficient(x2, 30) profit.SetMaximization() status = simpleprod.Solve() if status not in [simpleprod.OPTIMAL, simpleprod.FEASIBLE]: raise Exception('No feasible solution found') print("The company should produce",round(x1.solution_value(),2),"units of product 1") print("The company should produce",round(x2.solution_value(),2),"units of product 2") print("The optimal profit is", round(profit.Value(),2), 'USD')
Linear Programming with OR-Tools.ipynb
rayjustinhuang/DataAnalysisandMachineLearning
mit
1. Download Text8 Corpus
import os.path if not os.path.isfile('text8'): !wget -c http://mattmahoney.net/dc/text8.zip !unzip text8.zip
docs/notebooks/nmslibtutorial.ipynb
RaRe-Technologies/gensim
lgpl-2.1
Import & Set up Logging I'm not going to set up logging due to the verbose input displaying in notebooks, but if you want that, uncomment the lines in the cell below.
LOGS = False if LOGS: import logging logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO)
docs/notebooks/nmslibtutorial.ipynb
RaRe-Technologies/gensim
lgpl-2.1
2. Build Word2Vec Model
from gensim.models import Word2Vec, KeyedVectors from gensim.models.word2vec import Text8Corpus # Using params from Word2Vec_FastText_Comparison params = { 'alpha': 0.05, 'size': 100, 'window': 5, 'iter': 5, 'min_count': 5, 'sample': 1e-4, 'sg': 1, 'hs': 0, 'negative': 5 } model = Word2Vec(Text8Corpus('text8'), **params) print(model)
docs/notebooks/nmslibtutorial.ipynb
RaRe-Technologies/gensim
lgpl-2.1
See the Word2Vec tutorial for how to initialize and save this model. Comparing the traditional implementation, Annoy and Nmslib approximation
# Set up the model and vector that we are using in the comparison from gensim.similarities.index import AnnoyIndexer from gensim.similarities.nmslib import NmslibIndexer model.init_sims() annoy_index = AnnoyIndexer(model, 300) nmslib_index = NmslibIndexer(model, {'M': 100, 'indexThreadQty': 1, 'efConstruction': 100}, {'efSearch': 10}) # Dry run to make sure both indices are fully in RAM vector = model.wv.syn0norm[0] print(model.most_similar([vector], topn=5, indexer=annoy_index)) print(model.most_similar([vector], topn=5, indexer=nmslib_index)) print(model.most_similar([vector], topn=5)) import time import numpy as np def avg_query_time(annoy_index=None, queries=1000): """ Average query time of a most_similar method over 1000 random queries, uses annoy if given an indexer """ total_time = 0 for _ in range(queries): rand_vec = model.wv.syn0norm[np.random.randint(0, len(model.wv.vocab))] start_time = time.clock() model.most_similar([rand_vec], topn=5, indexer=annoy_index) total_time += time.clock() - start_time return total_time / queries queries = 10000 gensim_time = avg_query_time(queries=queries) annoy_time = avg_query_time(annoy_index, queries=queries) nmslib_time = avg_query_time(nmslib_index, queries=queries) print("Gensim (s/query):\t{0:.5f}".format(gensim_time)) print("Annoy (s/query):\t{0:.5f}".format(annoy_time)) print("Nmslib (s/query):\t{0:.5f}".format(nmslib_time)) speed_improvement_gensim = gensim_time / nmslib_time speed_improvement_annoy = annoy_time / nmslib_time print ("\nNmslib is {0:.2f} times faster on average on this particular run".format(speed_improvement_gensim)) print ("\nNmslib is {0:.2f} times faster on average than annoy on this particular run".format(speed_improvement_annoy))
docs/notebooks/nmslibtutorial.ipynb
RaRe-Technologies/gensim
lgpl-2.1
3. Construct Nmslib Index with model & make a similarity query Creating an indexer An instance of NmslibIndexer needs to be created in order to use Nmslib in gensim. The NmslibIndexer class is located in gensim.similarities.nmslib NmslibIndexer() takes three parameters: model: A Word2Vec or Doc2Vec model index_params: Parameters for building nmslib indexer. index_params effects the build time and the index size. The example is {'M': 100, 'indexThreadQty': 1, 'efConstruction': 100}. Increasing the value of M and efConstruction improves the accuracy of search. However this also leads to longer indexing times. indexThreadQty is the number of thread. query_time_params: Parameters for querying on nmslib indexer. query_time_params effects the query time and the search accuracy. The example is {'efSearch': 100}. A larger efSearch will give more accurate results, but larger query time. More information can be found here. The relationship between parameters, build/query time, and accuracy will be investigated later in the tutorial. Now that we are ready to make a query, lets find the top 5 most similar words to "science" in the Text8 corpus. To make a similarity query we call Word2Vec.most_similar like we would traditionally, but with an added parameter, indexer. The only supported indexerers in gensim as of now are Annoy and Nmslib.
# Building nmslib indexer nmslib_index = NmslibIndexer(model, {'M': 100, 'indexThreadQty': 1, 'efConstruction': 100}, {'efSearch': 10}) # Derive the vector for the word "science" in our model vector = model["science"] # The instance of AnnoyIndexer we just created is passed approximate_neighbors = model.most_similar([vector], topn=11, indexer=nmslib_index) # Neatly print the approximate_neighbors and their corresponding cosine similarity values print("Approximate Neighbors") for neighbor in approximate_neighbors: print(neighbor) normal_neighbors = model.most_similar([vector], topn=11) print("\nNormal (not nmslib-indexed) Neighbors") for neighbor in normal_neighbors: print(neighbor)
docs/notebooks/nmslibtutorial.ipynb
RaRe-Technologies/gensim
lgpl-2.1
Analyzing the results The closer the cosine similarity of a vector is to 1, the more similar that word is to our query, which was the vector for "science". In this case the results are almostly same. 4. Verify & Evaluate performance Persisting Indexes You can save and load your indexes from/to disk to prevent having to construct them each time. This will create two files on disk, fname and fname.d. Both files are needed to correctly restore all attributes.
import os fname = '/tmp/mymodel.index' # Persist index to disk nmslib_index.save(fname) # Load index back if os.path.exists(fname): nmslib_index2 = NmslibIndexer.load(fname) nmslib_index2.model = model # Results should be identical to above vector = model["science"] approximate_neighbors2 = model.most_similar([vector], topn=11, indexer=nmslib_index2) for neighbor in approximate_neighbors2: print(neighbor) assert approximate_neighbors == approximate_neighbors2
docs/notebooks/nmslibtutorial.ipynb
RaRe-Technologies/gensim
lgpl-2.1
Be sure to use the same model at load that was used originally, otherwise you will get unexpected behaviors. Save memory by memory-mapping indices saved to disk Nmslib library has a useful feature that indices can be memory-mapped from disk. It saves memory when the same index is used by several processes. Below are two snippets of code. First one has a separate index for each process. The second snipped shares the index between two processes via memory-mapping. The second example uses less total RAM as it is shared.
# Remove verbosity from code below (if logging active) if LOGS: logging.disable(logging.CRITICAL) from multiprocessing import Process import psutil
docs/notebooks/nmslibtutorial.ipynb
RaRe-Technologies/gensim
lgpl-2.1
Bad Example: Two processes load the Word2vec model from disk and create there own Nmslib indices from that model.
%%time model.save('/tmp/mymodel.pkl') def f(process_id): print('Process Id: {}'.format(os.getpid())) process = psutil.Process(os.getpid()) new_model = Word2Vec.load('/tmp/mymodel.pkl') vector = new_model["science"] nmslib_index = NmslibIndexer(new_model, {'M': 100, 'indexThreadQty': 1, 'efConstruction': 100}, {'efSearch': 10}) approximate_neighbors = new_model.most_similar([vector], topn=5, indexer=nmslib_index) print('\nMemory used by process {}: {}\n---'.format(os.getpid(), process.memory_info())) # Creating and running two parallel process to share the same index file. p1 = Process(target=f, args=('1',)) p1.start() p1.join() p2 = Process(target=f, args=('2',)) p2.start() p2.join()
docs/notebooks/nmslibtutorial.ipynb
RaRe-Technologies/gensim
lgpl-2.1
Good example. Two processes load both the Word2vec model and index from disk and memory-map the index
%%time model.save('/tmp/mymodel.pkl') def f(process_id): print('Process Id: {}'.format(os.getpid())) process = psutil.Process(os.getpid()) new_model = Word2Vec.load('/tmp/mymodel.pkl') vector = new_model["science"] nmslib_index = NmslibIndexer.load('/tmp/mymodel.index') nmslib_index.model = new_model approximate_neighbors = new_model.most_similar([vector], topn=5, indexer=nmslib_index) print('\nMemory used by process {}: {}\n---'.format(os.getpid(), process.memory_info())) # Creating and running two parallel process to share the same index file. p1 = Process(target=f, args=('1',)) p1.start() p1.join() p2 = Process(target=f, args=('2',)) p2.start() p2.join()
docs/notebooks/nmslibtutorial.ipynb
RaRe-Technologies/gensim
lgpl-2.1
5. Evaluate relationship of parameters to initialization/query time and accuracy, compared with annoy
import matplotlib.pyplot as plt %matplotlib inline
docs/notebooks/nmslibtutorial.ipynb
RaRe-Technologies/gensim
lgpl-2.1
Build dataset of Initialization times and accuracy measures
exact_results = [element[0] for element in model.most_similar([model.wv.syn0norm[0]], topn=100)] # For calculating query time queries = 1000 def create_evaluation_graph(x_values, y_values_init, y_values_accuracy, y_values_query, param_name): plt.figure(1, figsize=(12, 6)) plt.subplot(231) plt.plot(x_values, y_values_init) plt.title("{} vs initalization time".format(param_name)) plt.ylabel("Initialization time (s)") plt.xlabel(param_name) plt.subplot(232) plt.plot(x_values, y_values_accuracy) plt.title("{} vs accuracy".format(param_name)) plt.ylabel("% accuracy") plt.xlabel(param_name) plt.tight_layout() plt.subplot(233) plt.plot(y_values_init, y_values_accuracy) plt.title("Initialization time vs accuracy") plt.ylabel("% accuracy") plt.xlabel("Initialization time (s)") plt.tight_layout() plt.subplot(234) plt.plot(x_values, y_values_query) plt.title("{} vs query time".format(param_name)) plt.ylabel("query time") plt.xlabel(param_name) plt.tight_layout() plt.subplot(235) plt.plot(y_values_query, y_values_accuracy) plt.title("query time vs accuracy") plt.ylabel("% accuracy") plt.xlabel("query time (s)") plt.tight_layout() plt.show() def evaluate_nmslib_performance(parameter, is_parameter_query, parameter_start, parameter_end, parameter_step): nmslib_x_values = [] nmslib_y_values_init = [] nmslib_y_values_accuracy = [] nmslib_y_values_query = [] index_params = {'M': 100, 'indexThreadQty': 10, 'efConstruction': 100, 'post': 0} query_params = {'efSearch': 100} for x in range(parameter_start, parameter_end, parameter_step): nmslib_x_values.append(x) start_time = time.time() if is_parameter_query: query_params[parameter] = x else: index_params[parameter] = x nmslib_index = NmslibIndexer(model , index_params , query_params) nmslib_y_values_init.append(time.time() - start_time) approximate_results = model.most_similar([model.wv.syn0norm[0]], topn=100, indexer=nmslib_index) top_words = [result[0] for result in approximate_results] nmslib_y_values_accuracy.append(len(set(top_words).intersection(exact_results))) nmslib_y_values_query.append(avg_query_time(nmslib_index, queries=queries)) create_evaluation_graph(nmslib_x_values, nmslib_y_values_init, nmslib_y_values_accuracy, nmslib_y_values_query, parameter) # Evaluate nmslib indexer, changing the parameter M evaluate_nmslib_performance("M", False, 50, 401, 50) # Evaluate nmslib indexer, changing the parameter efConstruction evaluate_nmslib_performance("efConstruction", False, 50, 1001, 100) # Evaluate nmslib indexer, changing the parameter efSearch evaluate_nmslib_performance("efSearch", True, 50, 401, 100) # Evaluate annoy indexer, changing the parameter num_tree annoy_x_values = [] annoy_y_values_init = [] annoy_y_values_accuracy = [] annoy_y_values_query = [] for x in range(100, 401, 50): annoy_x_values.append(x) start_time = time.time() annoy_index = AnnoyIndexer(model, x) annoy_y_values_init.append(time.time() - start_time) approximate_results = model.most_similar([model.wv.syn0norm[0]], topn=100, indexer=annoy_index) top_words = [result[0] for result in approximate_results] annoy_y_values_accuracy.append(len(set(top_words).intersection(exact_results))) annoy_y_values_query.append(avg_query_time(annoy_index, queries=queries)) create_evaluation_graph(annoy_x_values, annoy_y_values_init, annoy_y_values_accuracy, annoy_y_values_query, "num_tree") # nmslib indexer changing the parameter M, efConstruction, efSearch nmslib_y_values_init = [] nmslib_y_values_accuracy = [] nmslib_y_values_query = [] for M in [100, 200]: for efConstruction in [100, 200]: for efSearch in [100, 200]: start_time = time.time() nmslib_index = NmslibIndexer(model, {'M': M, 'indexThreadQty': 10, 'efConstruction': efConstruction, 'post': 0}, {'efSearch': efSearch}) nmslib_y_values_init.append(time.time() - start_time) approximate_results = model.most_similar([model.wv.syn0norm[0]], topn=100, indexer=nmslib_index) top_words = [result[0] for result in approximate_results] nmslib_y_values_accuracy.append(len(set(top_words).intersection(exact_results))) nmslib_y_values_query.append(avg_query_time(nmslib_index, queries=queries)) # Make a comparison between annoy and nmslib indexer plt.figure(1, figsize=(12, 6)) plt.subplot(121) plt.scatter(nmslib_y_values_init, nmslib_y_values_accuracy, label="nmslib", color='r', marker='o') plt.scatter(annoy_y_values_init, annoy_y_values_accuracy, label="annoy", color='b', marker='x') plt.legend() plt.title("Initialization time vs accuracy. Upper left is better.") plt.ylabel("% accuracy") plt.xlabel("Initialization time (s)") plt.subplot(122) plt.scatter(nmslib_y_values_query, nmslib_y_values_accuracy, label="nmslib", color='r', marker='o') plt.scatter(annoy_y_values_query, annoy_y_values_accuracy, label="annoy", color='b', marker='x') plt.legend() plt.title("Query time vs accuracy. Upper left is better.") plt.ylabel("% accuracy") plt.xlabel("Query time (s)") plt.xlim(min(nmslib_y_values_query+annoy_y_values_query), max(nmslib_y_values_query+annoy_y_values_query)) plt.tight_layout() plt.show()
docs/notebooks/nmslibtutorial.ipynb
RaRe-Technologies/gensim
lgpl-2.1
6. Work with Google word2vec files Our model can be exported to a word2vec C format. There is a binary and a plain text word2vec format. Both can be read with a variety of other software, or imported back into gensim as a KeyedVectors object.
# To export our model as text model.wv.save_word2vec_format('/tmp/vectors.txt', binary=False) from smart_open import open # View the first 3 lines of the exported file # The first line has the total number of entries and the vector dimension count. # The next lines have a key (a string) followed by its vector. with open('/tmp/vectors.txt') as myfile: for i in range(3): print(myfile.readline().strip()) # To import a word2vec text model wv = KeyedVectors.load_word2vec_format('/tmp/vectors.txt', binary=False) # To export our model as binary model.wv.save_word2vec_format('/tmp/vectors.bin', binary=True) # To import a word2vec binary model wv = KeyedVectors.load_word2vec_format('/tmp/vectors.bin', binary=True) # To create and save Nmslib Index from a loaded `KeyedVectors` object nmslib_index = NmslibIndexer(wv, {'M': 100, 'indexThreadQty': 1, 'efConstruction': 100}, {'efSearch': 100}) nmslib_index.save('/tmp/mymodel.index') # Load and test the saved word vectors and saved nmslib index wv = KeyedVectors.load_word2vec_format('/tmp/vectors.bin', binary=True) nmslib_index = NmslibIndexer.load('/tmp/mymodel.index') nmslib_index.model = wv vector = wv["cat"] approximate_neighbors = wv.most_similar([vector], topn=11, indexer=nmslib_index) # Neatly print the approximate_neighbors and their corresponding cosine similarity values print("Approximate Neighbors") for neighbor in approximate_neighbors: print(neighbor) normal_neighbors = wv.most_similar([vector], topn=11) print("\nNormal (not Nmslib-indexed) Neighbors") for neighbor in normal_neighbors: print(neighbor)
docs/notebooks/nmslibtutorial.ipynb
RaRe-Technologies/gensim
lgpl-2.1

This is a parsed version of github-jupyter-parsed, with markdown and code pairs. We provide the preprocessing script in preprocessing.py. The data is deduplicated and consists of 451662 examples.

For similar datasets with text and Python code, there is CoNaLa benchmark from StackOverflow, with some samples curated by annotators.

Downloads last month
167