Note
Click here to download the full example code
Discriminative connection identification¶
What you’ll learn: Build a model around the weight of a linear classifier to identify the discriminant connections.
Author: Dhaif BEKHA
Retrieve the example dataset¶
In this example, we will work directly on a pre-computed dictionary, that contain two set of connectivity matrices, from two different groups. The first group, called controls is a set of connectivity matrices from healthy seven years old children, and the second group called patients, is a set of connectivity matrices from seven years old children who have suffered a stroke. You can download the dictionary use in this example here. Finally, we will plot some results on a glass brain, and we will need the nodes coordinates of the atlas regions in which the signals were extracted. You can download the atlas, and the corresponding labels. As usual, we will suppose that all needed files are in your home directory.
Modules import¶
from pathlib import Path
import os
from conpagnon.utils.folders_and_files_management import load_object
from conpagnon.machine_learning.features_indentification import discriminative_brain_connection_identification, \
find_top_features
import numpy as np
from conpagnon.data_handling import atlas
from conpagnon.utils.array_operation import array_rebuilder
from nilearn.connectome import sym_matrix_to_vec
from sklearn.model_selection import cross_val_score, StratifiedShuffleSplit
from sklearn.svm import LinearSVC
import matplotlib.pyplot as plt
import pandas as pd
Load data¶
We load the subjects connectivity matrices dictionary, and the atlas that you previously downloaded.
# Fetch the path of the home directory
home_directory = str(Path.home())
# Filename of the atlas file.
atlas_file_name = 'atlas.nii'
# Full path to atlas labels file
atlas_label_file = os.path.join(home_directory, 'atlas_labels.csv')
# Set the colors of the twelves network in the atlas
colors = ['navy', 'sienna', 'orange', 'orchid', 'indianred', 'olive',
'goldenrod', 'turquoise', 'darkslategray', 'limegreen', 'black',
'lightpink']
# Number of regions in each of the network
networks = [2, 10, 2, 6, 10, 2, 8, 6, 8, 8, 6, 4]
# We can call fetch_atlas to retrieve useful information about the atlas
atlas_nodes, labels_regions, labels_colors, n_nodes = atlas.fetch_atlas(
atlas_folder=home_directory,
atlas_name=atlas_file_name,
network_regions_number=networks,
colors_labels=colors,
labels=atlas_label_file,
normalize_colors=True)
# We now fetch the subjects connectivity dictionary
# Load the dictionary containing the connectivity matrices
subjects_connectivity_matrices = load_object(
full_path_to_object=os.path.join(home_directory, 'raw_subjects_connectivity_matrices.pkl'))
# Groups names in the dictionary
groups = list(subjects_connectivity_matrices.keys())
Understand and analyze the results of a classifier¶
In the basic section, we saw an example of two groups classification using a classifier, a **S**upport **V**ector **M**achine (SVM) with a linear kernel. Please, do not hesitate to go back to the two groups classification tutorial if needed. Briefly, with a SVM we perform a classification task between patients and controls, with a Stratified and Shuffle cross-validation scheme. This task is performed for the correlation, partial correlation and tangent space connectivity matrices. We compute and store the accuracy for each of those connectivity metric.
# Labels vectors: 0 for the first class, 1 for the second. Those
# 1, and 0 are the label for each subjects.
class_labels = np.hstack((np.zeros(len(subjects_connectivity_matrices[groups[0]].keys())),
np.ones(len(subjects_connectivity_matrices[groups[1]].keys()))))
# total number of subject
n_subjects = len(class_labels)
# Stratified Shuffle and Split cross validation:
# we initialize the cross validation object
# and set the split to 10000.
cv = StratifiedShuffleSplit(n_splits=10000,
random_state=0)
# Instance initialization of SVM classifier with a linear kernel
svc = LinearSVC()
# Compare the classification accuracy across multiple metric
metrics = ['tangent', 'correlation', 'partial correlation']
mean_scores = []
# To decrease the computation time you
# can distribute the computation on
# multiple core, here, 4.
n_jobs = 4
# Final mean accuracy scores will be stored in a dictionary
mean_score_dict = {}
for metric in metrics:
# We take the lower triangle of each matrices, and vectorize it to
# produce a classical machine learning data array of shape (n_subjects, n_features)
features = sym_matrix_to_vec(np.array([subjects_connectivity_matrices[group][subject][metric]
for group in groups
for subject in subjects_connectivity_matrices[group].keys()],
), discard_diagonal=True)
print('Evaluate classification performance on {} with '
'{} observations and {} features...'.format(metric, n_subjects, features.shape[1]))
# We call cross_val_score, a convenient scikit-learn
# wrapper that will perform the classification task
# with the desired cross-validation scheme.
cv_scores = cross_val_score(estimator=svc, X=features,
y=class_labels, cv=cv,
scoring='accuracy', n_jobs=n_jobs)
# We compute the mean cross-validation score
# over all the splits
mean_scores.append(cv_scores.mean())
# We store the mean accuracy score
# in a dictionary.
mean_score_dict[metric] = cv_scores.mean()
print('Done for {}'.format(metric))
# Lets print out the accuracy for each metric
for metric in metrics:
print('{} accuracy: {} %'.format(metric, mean_score_dict[metric] * 100))
Out:
Evaluate classification performance on tangent with 53 observations and 2556 features...
Done for tangent
Evaluate classification performance on correlation with 53 observations and 2556 features...
Done for correlation
Evaluate classification performance on partial correlation with 53 observations and 2556 features...
Done for partial correlation
tangent accuracy: 89.69000000000001 %
correlation accuracy: 82.03833333333334 %
partial correlation accuracy: 87.58666666666667 %
We input a set of 2556
features, i.e, the connectivity coefficients,
to the classifier. In the training phase, the classifier give a
weight to each input features. It’s very common that
the features have not the same importance in the decision
whether for a given subject it’s a patient or a control
subject. If we simplify, some feature are “not so important”
in the final decision, and they have a “small weight” compared
to some other feature that are more important in the final
decision, with higher weight. The idea of the algorithm
that we detailed below is explore the classifier weight
and build a statistic for those weight to find the
more important one.
Important
We will use the tangent space metric only for the rest of this tutorial. The tangent space metric is better suited for classification task, and in general, to pinpoint individual difference in functional connectivity. We detailed why in another tutorial of the advanced examples. Do not hesitate to dive deeper in the subject if you need to.
Discriminative connection identification: the algorithm¶
The presented algorithm was created by Bertrand Ng & al, and we encourage you to read the full paper with a deeper dive in the theory here. Let’s consider we have \({ d\Sigma^{1} ... d\Sigma^{S} }\), the tangent matrices of the whole cohort (patients and controls), with the corresponding labels vector \([0, 0, ..., 1, 1 ,1]\), coding \(0\) for a control subject, and \(1\) for a patient. We first compute the classification for this set of tangent matrices and labels, which results in a vector of weights, \(\omega\). We then, randomly permute \(N\) times the labels vector. Then, for each permutation, we perform the classifier learning on a bootstrapped sample of size \(B\). So, for each permutation, for each bootstrapped sample we compute the classifier weights \(\omega_{n, b}\) with \(b \in {1, ... B}\) and \(n \in {1, ... N}\). For each permutation we ended up with a matrix weight of size \((B, n_{features})\). We then compute the normalized weight over the bootstrapped sample:
We then, store the maximum normalized weight for the permutation \(n\). This is the null distribution of maximum normalized weight mean. After the \(N\) permutation we compute \(\Omega_{0} = \frac{1}{B} \frac{\sum_{b=1}^{B}\omega_{b}}{std(\omega_{b})}\) which is simply the normalized weight without permutations. Giving the We finally declare a weight of \(\Omega_{0}\) significant if they are greater than the 99 th percentile of the null distribution, corresponding to a p-value threshold of 0.01. We use the same classifier as the classification task above, that is, a SVM with a linear kernel. We keep the regularization term C to the default value one.
Note
For the negative weights, we store the minimum of the normalized weight mean instead of the maximum. In the end, you will end up with a set of significant negative weight, and a set of positive one. This way of assessing significance is often called maxT (or minT)
We build a function that conveniently wrap all the
detailed step above,
conpagnon.machine_learning.features_indentification.discriminative_brain_connection_identification()
.
This function parallelize the computation of the bootstrapped weights. In this function, you can also
choose a parametric correction like FDR for example. I encourage you to look up to the docstring before
using it. We write all the useful results in a report, including the top weight labels.
# Stacked the 2D array of connectivity matrices for each subjects
class_names = groups
metric = 'tangent'
# Vectorize the connectivity matrices
vectorized_connectivity_matrices = sym_matrix_to_vec(
np.array([subjects_connectivity_matrices[class_name][s][metric] for class_name
in class_names for s in subjects_connectivity_matrices[class_name].keys()]),
discard_diagonal=True)
# Stacked connectivity matrices
stacked_connectivity_matrices = np.array([subjects_connectivity_matrices[class_name][s][metric]
for class_name in class_names
for s in subjects_connectivity_matrices[class_name].keys()])
# Compute mean connectivity matrices for each class
# for plotting purpose only
first_class_mean_matrix = np.array([subjects_connectivity_matrices[class_names[0]][s][metric] for s in
subjects_connectivity_matrices[class_names[0]].keys()]).mean(axis=0)
second_class_mean_matrix = np.array([subjects_connectivity_matrices[class_names[1]][s][metric] for s in
subjects_connectivity_matrices[class_names[1]].keys()]).mean(axis=0)
# Directory where you wan to save the report
save_directory = home_directory
# Labels vectors
class_labels = np.hstack((1*np.ones(len(subjects_connectivity_matrices[class_names[0]].keys())),
-1*np.ones(len(subjects_connectivity_matrices[class_names[1]].keys()))))
classifier_weights, weight_null_distribution, p_values_corrected = \
discriminative_brain_connection_identification(
vectorized_connectivity_matrices=vectorized_connectivity_matrices,
class_labels=class_labels,
class_names=class_names,
save_directory=save_directory,
n_permutations=100,
bootstrap_number=200,
features_labels=labels_regions,
features_colors=labels_colors,
n_nodes=n_nodes,
atlas_nodes=atlas_nodes,
first_class_mean_matrix=first_class_mean_matrix,
second_class_mean_matrix=second_class_mean_matrix,
n_cpus_bootstrap=8,
top_features_number=10,
write_report=True,
correction='fdr_bh',
C=1)
Out:
Check Bootstrapped class labels for each permutation...
Verifying that bootstrapped sample labels classes contain two labels....
Done checking bootstrapped class labels for each permutation.
Performing classification on 200 bootstrap sample...
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.7s finished
Performing permutation number 0 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 1 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 2 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 3 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 4 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 5 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 6 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 7 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 8 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 9 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 10 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 11 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 12 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 13 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 14 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 15 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 16 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 17 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 18 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 19 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 20 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 21 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 22 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 23 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 24 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 25 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 26 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 27 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 28 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 29 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 30 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 31 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 32 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 33 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 34 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.8s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 35 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 36 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 37 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 38 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 39 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 40 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.8s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 41 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 42 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 43 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.9s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 3.0s finished
Performing permutation number 44 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.9s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.8s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 45 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 46 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 47 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 48 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 49 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 50 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 51 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 52 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 53 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 54 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 55 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 56 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 57 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 58 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 59 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 60 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 61 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 62 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 63 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 64 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 65 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 66 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 67 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 68 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.8s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 69 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 70 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 71 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 72 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 73 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 74 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 75 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 76 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 77 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.6s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 78 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 79 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 80 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 81 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 82 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 83 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 84 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 85 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 86 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 87 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 88 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.9s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 89 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 90 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 91 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.9s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.9s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 3.0s finished
Performing permutation number 92 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 93 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 94 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 95 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.9s finished
Performing permutation number 96 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 97 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 98 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 185 out of 200 | elapsed: 2.7s remaining: 0.2s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Performing permutation number 99 out of 100
[Parallel(n_jobs=8)]: Using backend MultiprocessingBackend with 8 concurrent workers.
[Parallel(n_jobs=8)]: Done 52 tasks | elapsed: 0.8s
[Parallel(n_jobs=8)]: Done 200 out of 200 | elapsed: 2.8s finished
Elapsed time for 100 permutations: 5.099279391765594 min
/home/dhaif/anaconda3/envs/conpagnon/lib/python3.7/site-packages/nilearn/plotting/displays.py:1752: FutureWarning: elementwise comparison failed; returning scalar instead, but in the future will perform elementwise comparison
if node_color == 'auto':
Danger
For the sake of computation time, we choose to compute 500 permutation on bootstrapped sample of size 200. We recommend that you runs at least 10,000 permutation on 500 bootstrapped sample size. We also choose a less conservative correction than the original algorithm, a FDR correction dealing with the multiple comparison.
We will not recreate exactly all the plot and information you’ll find in the final report, but in the section below we will first plot the histogram of the top-weight for both positive and negative weights. The full report is stored in your home directory, and contains all the figure, along with a text file with all the analytics you’ll need.
# Find top features
# Rebuild a symmetric array from normalized mean weight vector
normalized_mean_weight_array = array_rebuilder(classifier_weights,
'numeric', diagonal=np.zeros(n_nodes))
normalized_mean_weight_array_top_features, top_weights, top_coefficients_indices, top_weight_labels = \
find_top_features(normalized_mean_weight_array=normalized_mean_weight_array,
labels_regions=labels_regions,
top_features_number=19)
# Convert the array of labels regions into
# a list of string for plotting purpose.
labels_str = []
for i in range(top_weight_labels.shape[0]):
labels_str.append(str(top_weight_labels[i]))
# let's plot the top negative and positive weight
# on a bar plot
weight_colors = ['blue' if weight < 0 else 'red' for weight in top_weights]
plt.bar(np.arange(len(top_weights)), list(top_weights),
color=weight_colors,
edgecolor='black',
alpha=0.5)
plt.xticks(np.arange(0, len(top_weights)), labels_str,
rotation=60,
ha='right')
for label in range(len(plt.gca().get_xticklabels())):
plt.gca().get_xticklabels()[label].set_color(weight_colors[label])
plt.xlabel('Features names')
plt.ylabel('Features weights')
plt.title('Top {} features ranking of normalized mean weight'.format(20))
plt.show()
Out:
/media/dhaif/Samsung_T5/Work/Programs/ConPagnon/examples/04_Advanced_Statistical_Analyses/plot_discriminative_connection_identification.py:331: UserWarning: Matplotlib is currently using agg, which is a non-GUI backend, so cannot show the figure.
plt.show()
Note
The barplot above give you a sense of what will be the import feature, i.e, pairs of regions, that will have a huge impact on the classification decision. For example, it seems that the connectivity between the left and right supra-marginal gyrus and also for the intra-parietal sulcus plays an important role in the classification decision.
Let’s load the text file generated by the analysis. The text file should in your home directory.
# Load the text file:
text_filename = 'features_identification_patients_controls_0.05_fdr_bh.txt'
discriminative_connection_identification_report = pd.read_table(os.path.join(home_directory, text_filename))
print(discriminative_connection_identification_report.to_markdown())
Out:
| | ------------ Parameters ------------ |
|---:|:----------------------------------------------------------------------------------------|
| 0 | Number of subjects: 53 |
| 1 | Groups: ['patients', 'controls'] |
| 2 | Groups labels: [ 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. |
| 3 | 1. 1. 1. 1. 1. 1. 1. 1. 1. -1. -1. -1. -1. -1. -1. -1. -1. -1. |
| 4 | -1. -1. -1. -1. -1. -1. -1. -1. -1. -1. -1. -1. -1. -1. -1. -1. -1.] |
| 5 | Bootstrap number: 200 |
| 6 | Number of permutations: 100 |
| 7 | Alpha threshold: 0.05 |
| 8 | Regularization parameters C: 1 |
| 9 | ------------ Results ------------ |
| 10 | ------------ Discriminative connections for negative features weight ------------ |
| 11 | Precent_Inf_2_R <-> Precent_Inf_2_L, (indices: 0 <-> 1) |
| 12 | Planum_T_L <-> Planum_T_R, (indices: 2 <-> 3) |
| 13 | Precent_Inf_1_R <-> POS_Sup_R, (indices: 5 <-> 12) |
| 14 | Front_Op_L <-> Front_Op_R, (indices: 22 <-> 29) |
| 15 | SMG_L <-> SMG_R, (indices: 23 <-> 28) |
| 16 | BG_1_L <-> BG_1_R, (indices: 30 <-> 31) |
| 17 | IPS_Int_L <-> IPS_Int_R, (indices: 54 <-> 57) |
| 18 | IPS_Sup_L <-> IPS_Sup_R, (indices: 59 <-> 60) |
| 19 | ------------ Discriminative connections for positive features weight ------------ |
| 20 | Precent_Inf_2_L <-> Precent_Inf_1_L, (indices: 1 <-> 4) |
| 21 | POS_Sup_L <-> Precun_Inf_L, (indices: 13 <-> 36) |
| 22 | CentSulc_Sup_R <-> Cing_Ant_R, (indices: 19 <-> 33) |
| 23 | SMG_L <-> IPS_Sup_L, (indices: 23 <-> 59) |
| 24 | Cun_Sup_R <-> Ling_R, (indices: 40 <-> 53) |
In the text report, you find the full list of the regions that are the most important in the decision, that is, the regions which the p-value associated to the attached weight that are significant. In the pdf report you will find a glass brain plot with the significant positive and negative regions.
Total running time of the script: ( 7 minutes 16.379 seconds)


×
Congratulations!
You have completed the game successfully! Click x to close the alert and reset the game.


LambdaTransform provides an easy way of creating custom transformations without having to create new Transform classes. You just create a transform function and feed that to a LambdaTransform constructor together with possible configuration parameters values and configuration parameter metadata (key names and descriptions).
- Template Parameters
-
Definition at line 68 of file lambda_transform.h.
template<class IN , class OUT , class P1 = bool, class P2 = bool, class P3 = bool, class P4 = bool, class P5 = bool, class P6 = bool>
| LambdaTransform< IN, OUT, P1, P2, P3, P4, P5, P6 >::LambdaTransform |
( |
OUT(*)(IN input, P1 param1, P2 param2) |
function, |
|
|
P1 |
param1, |
|
|
P2 |
param2, |
|
|
const ParamInfo * |
param_info, |
|
|
String |
config_path = "" |
|
) |
| |
|
inline |
LambdaTransform constructor for two-parameter function.
Construct a new LambdaTransform object which takes an input and two configuration parameters. Multiple overloaded constructors exist; their arguments can be extrapolated from this one.
- Parameters
-
| function | Function to be executed for every new input value |
| param1 | Configuration parameter 1 |
| param2 | Configuration parameter 2 |
| param_info | Keys and Descriptions of each configuration parameter |
| config_path | Configuration path for the transform |
Definition at line 107 of file lambda_transform.h.
template<class IN , class OUT , class P1 = bool, class P2 = bool, class P3 = bool, class P4 = bool, class P5 = bool, class P6 = bool>
| void LambdaTransform< IN, OUT, P1, P2, P3, P4, P5, P6 >::get_configuration |
( |
JsonObject & |
doc | ) |
|
|
inlineoverride |
template<class IN , class OUT , class P1 = bool, class P2 = bool, class P3 = bool, class P4 = bool, class P5 = bool, class P6 = bool>
| bool LambdaTransform< IN, OUT, P1, P2, P3, P4, P5, P6 >::set_configuration |
( |
const JsonObject & |
config | ) |
|
|
inlineoverride |
template<class IN , class OUT , class P1 = bool, class P2 = bool, class P3 = bool, class P4 = bool, class P5 = bool, class P6 = bool>
| void LambdaTransform< IN, OUT, P1, P2, P3, P4, P5, P6 >::set_input |
( |
IN |
input, |
|
|
uint8_t |
input_channel = 0 |
|
) |
| |
|
inlineoverride |


Karan Pizza
Karan Pizza
Serving your daily pizza cravings! Available through online order only.
*Delivery within Nairobi
Pickup
Delivery
Delivery Address
First Name
Last Name
Address
Constituency
Dagoretti
Embakasi
Kamukunji
Kasarani
Kibra
Roysambu
starehe
Westlands
Langata
Makadara
Submit
Order Options
pizza
Cheese Tikka
Regular
Medium
Large
Pepperoni tikka
Regular
Medium
Large
Veggie Tikka
Regular
Medium
Large
Order Form
Order Here!
Size
Regular @Ksh500
Medium @Ksh800
Large @Ksh1000
Flavour
Veg Tikka
Chicken Tikka
Pepperoni Tikka
Italian Tikka
Crust
Crispy @Ksh100
stuffed @Ksh150
Gluten-free @Ksh200
Place Order
Toppings
Green-peppers
Onions
Mushrooms
Cart
Price: Ksh
Order Summary
Pizza
Toppings
Checkout


Automagically resizing iFrame
Resize window to see it in action.
For details on how this works, see
http://davidjbradshaw.github.io/iframe-resizer/
.


Hello! 👋 My name is Roberts Vartins.
I am a passionate software engineer who likes new challenges and learning new things.
I love Java, AWS and everything about software engineering.


Oops! You need to give access to this app through Reddit before using it. We promise it is safe! Just follow the link, and you will be redirected to Reddit for authenticating.


A list of free and useful data warehouses and APIs.
Free weather data.
Dark Skys
Need information about America's people? This is the place.
Census Demographic Data
A bunch of data from all sorts of government agencies.
Data from the Government local & National
PS, This article on Forbes list tons of free data Sources.


Thank You!
I appreciate you taking the time to get to know more about me!
Here's a picture of a cat!
TOP TEN FAVORITE MOVIES
I would like to list these for you to sort of give you another little glimpse into my mind!
- Lords of Dogtown
- Six-String Samurai
- Mallrats
- Dope
- Kubo and the Two Strings
- Emperor's New Groove
- 30 Days of Night
- Inception
- Deathgasm
- Mean Girls


Leadership
My experience of compassionate (or not) leadership?
This is an interesting question since for the past 10 years I've been working for a professional development company with an extremely strong focus on teaching compassionate/empathetic leadership. Having a leader who walks the talk - and obviuosly being deeply involved in this topic through my career - has had an immense input on what I value, how I treat others and how I want to be treated. From a personal experience I can say that the amount of personal growth and organisational happiness levels are huge.
On the flip side, having experienced great leadership trains you to spot terrible or no leadership. I have walked away from work situations that were unhealthy, largely because I know my values (and one of them is a healthy amount of self resepect). Thinking about what these "leaders" had in common I would definitely say absolute lack of interest in their workforce as human beings, hence no compassion, and certainly no amount of humbleness (as in being interested in other's opinions, being ok with uncertainty, trust etc.).
Have a difficult conversation. How did it go?
Difficult conversations are difficult, but can be extremely rewarding if they go well. Being aware that there is usually a sub-context of feelings and identity is super important. I would add to the suggested practice that difficult conversations should be announced and preferably with the topic (like "Hey, could we have a chat in the next hour about what happened yesterday?"). That way the other person isn't caught off-guard and immediately on the offense. Also taking a breath of two before responding can be really helpful to look at the conversation in a more detached way instead of just reacting on impulse.
Any other musings?
Yes, this book and I...we just didn't really work out. I'd like to say it's me, but ... I'm finding some parts of the book really non-reflective and questionable. Maybe this stems from years of researching these topics but I am still waiting for the book to finally start talking about BOUNDARIES! I agree with the overall sentiment of the book (and it is a great intro to mindfulness), but life (be that private or work) is not always as simple/simplistic as the book makes out. There are situations when it's sure nice to see the good in a person, but if that person is 99% not good (I did write something else here before), then loving kindness meditation and multiplying goodness visualisations are not what you want to do. Especially as a woman! Yes, of course seeing the good as opposed to having preconceived ideas is really valuable, but it can also be exploited (especially in work situations).
This part in particular did not do it for me:
"When you instinctively and habitually want to deliver goodness to the world,
pretty soon, you become the person who always wants to help others. Eventually, you become one whom people respect, sometimes
even admire, because they feel your heart is in the right place.”
NO! NO! NO! This is unreflective! Of course helping is great, but the way this is written is as if you will only get people's respect and admiration if you help others (helper syndrome here we come). It also turns helping from a selfless act into one that you do because you expect an outcome (respect in this case). Or what if you (or your boss or co-worker) lack humbleness and self-awareness and your /their helping is a cloaked form of patronising?
Of course there are times when helping is anything else but selfless (I help you so we get the job done on time), and that's fine. But then acknowledge that that's what it is and don't hide it behind it being done to deliver goodness to the world. Nor is it always advisable to help others without setting boundaries (otherwise you're risking being taken advantage of - and let's face it, if you're a woman reading this, or any minority who happens to not be a white male, then this warning won't be news to you).
If you've made it this far, I am ranting at something that I feel is missing in the book. Helping is important! Being an empathetic person is important! So are being kind, and listening, and aware of yourself and others and many other traits. But set boundaries! People will also respect you for knowing your own worth and for expressing it!
Home


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/mathlib.20pull.20requests.html ---
@Mario Carneiro and @Johannes Hölzl: There are a lot of pending PRs. What would you like to do with them?
I understand you were busy in Hanoi for a while. And perhaps you're still busy with other things. This is just a friendly ping to see what your status is.
Every now and then, something comes up that I want to contribute to mathlib, but then I see the list of pending PRs, and I get a bit discouraged, thinking that it might not be worth it. Some pretty simple PRs have not seen any response to indicate what will happen to them.
That said, if you need help managing contributions, I can volunteer some time. I can do commenting, labeling, and merging of simple PRs, while leaving the more interesting ones to you. (Of course, it's git
, so things can always be changed later.)
@Mario Carneiro Thanks for all your recent PR merges and comments. Just so you know, if you'd like more help with mathlib maintenance, my offer stands.
I did all the easy stuff. I'm still a bit busy with Tom Hales' conference this week, but some organization or prioritization of existing PRs would be a thing third parties could do to make it easier. Unfortunately in many of the remaining PRs there is something I see a problem with but I haven't found the time to write about it, so for those you may have to just wait or guess (or ask).
Anything I should be doing for refine_struct
?
I'd rather not merge conflicts from github, could you do that? Otherwise it's okay (the conversation and travis failure made it look more complicated than it is, but I see it's ready for merge now.)
Cool, sure thing
some organization or prioritization of existing PRs would be a thing third parties could do to make it easier.
Yeah, that's basically what I was thinking: triage with labels, assign issues and reviewers, ping the various parties every now and then, and update statuses. If it's an easy/obvious PR, merge it.
Unfortunately in many of the remaining PRs there is something I see a problem with but I haven't found the time to write about it, so for those you may have to just wait or guess (or ask).
Yep.
The build time for mathlib is truly incredible. I wonder if we could minimize the rebuild size on every change
This is where a lint tool would be very useful: we could find dead code and spurious dependencies
The refine_struct
in mathlib seems to be misbehaving. Here's my MWE:
import tactic.interactive variable (α : Type) def foo : semigroup α := begin refine_struct ({ .. } : semigroup α), end
Which just says failed
on the refine_struct
. It seems that it's failing at the very first line str ← e.get_structure_instance_info,
of refine_struct
.
(@Simon Hudon)
@Scott Morrison Would you mind creating a new GitHub issue with this information? It will make tracking the problem and its solution easier.
Can do! I thought that since it was such a basic thing I might be doing something stupid, and should ask here first. :-)
Can do! I thought that since it was such a basic thing I might be doing something stupid, and should ask here first. :-)
Even if it is something stupid, others might run into it, too. And it's still easier to search GitHub than Zulip. :wink:
(That's my personal experience, anyway. Others may have different thoughts.)
Of course, you can always check here first and put it there later, I suppose. But I think that creates extra work for you.
https://github.com/leanprover/mathlib/issues/160
(deleted)
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


--- layout: default ---
LightSAML is a stack of PHP libraries and bundles implementing OASIS' SAML 2.0 protocol.
A core library implementing data model, XML serialization/deserialization, bindings, and profiles.
A library implementing IDP side of the Web Browser Single SignOn SAML profile.
A library implementing the Web Browser Single Logout SAML profile.
A Symfony bridge bundle configuring internal profile services.
A Symfony bundle implementing Service Provider side of the Web Browser Single Sign On SAML profile as a Symfony security listener.


Introduction
- It was originally an HP research project between 1984 and 1994, which was presented at 1995 UNLV Annual Test of OCR Accuracy where it performed beyond expectations.
- Purpose of tesseract was integration with the flatbed HP scanners with objectives such as compression which was not possible with the then existing commercial OCR solutions which were struggling with accuracy.
- During a phase of development, work concentrated on improving rejection efficiency than on base-level accuracy.
- Finally in 2005, Tesseract was released as an open-source project by HP available at Google Code until it was finally moved to Github for open-source contribution.
Architecture
-
Because of HP’s proprietary layout analysis technology, Tesseract did not have it’s own dedicated layout analyser. As a result, Tesseract assumes the inputs to be binary image with optional polygonal text regions defined.
-
Connected Component Analysis is the first step in which the outlines of the components are stored. Outlines are gathered together, purely by nesting, into Blobs.
-
Blobs are organized into text lines, and the the lines and regions are analyzed for fixed pitch or proportional text. The lines are broken into words differently based on the kind of character spacing. Fixed pitch text is chopped immidiately by character cells. Proportional text is broken into words using definite spaces or fuzzy spaces.
-
Recognition proceeds as a two-pass process. During the first pass, attempt is made to recognize each word. The words that are satifactorily identified are passed to an adaptive classifier as training data. As a result the adaptive classifier gets a chance at improving results among text lower down on the page. In order to utilize the training of adaptive classifier on the text near the top of the page as second pass is performed, during which words that were not recognized well enough are classified again.
-
Final Phase resolves the fuzzy spaces, and checks alternative hypotheses for the x-height to locate small-cap text.
Line and Word Finding
1. Line Finding
-
Algorithm is designed so that skewed page can be recognized without having to deskew, thus preventing any loss of image quality.
-
Blob filtering and line construction are key parts of this process.
-
Under the assumption that most blobs have uniform text size, a simple percentile height filter removes drop-caps and vertically touching characters and median height approximates the text size in the region.
-
Blobs smaller than a certain fraction of the median height are filtered out, being most likely punctuation, diacritical marks and noise.
-
The filtered blobs are more likely to fit a model of non-overlapping, parallel, but sloping lines. Sorting and processing the blobs by x-coordinates makes it possible to assign blobs to a unique text line, while tracking the slope across the page.
-
Once the lines are assigned, a least median of squares fit is used to estimate the baselines, and filtered-out blobs are fitted back into appropriate lines.
-
Final step merges blobs that overlap by at least half horizontally, putting diacritical marks together with the correct base and correctly associating parts of some broken characters.
2. Baseline Fitting
- Using the text lines, baselines are fitted precisely using a quadratic spline, which allows Tesseract to handle pages with curved baselines.
- Baseline fitting is done by partitioning the blobs into groups of reasonable continuous displacement for the original straight baseline. A quadratic spline is fitted to the most populous partition by a least square fit.
3. Fixed Pitch Detection and Chopping
- Lines are tested to determine whether they are fixed pitch. Where it finds fixed pitch text, Tesseract chops the words into characters using pitch, and disables the chopper and associator on these words for the word recognition step.
4. Proportional Word Finding
- Detecting word boundaries in a not-fixed-pitch or proportional text spacing is highly non-trivial task.
-
For example, the gap between the tens and units of ‘11.9%’ is similar size to general space, but is certainly larger the kerned space between ‘erated’ and ‘junk’. Another case can be noticed that there is no horizontal gap between the bounding box of ‘of’ and ‘financial’.
-
Tesseract solves most of these problems by measuring gaps in a limited vertical range between baseline and mean line. Spaces close to a threshold are made fuzzy, where the decisions are made after word recognition.
Word Recognition
-
A major part of any word recognition algorithm is to identify how a word should be segmented into characters.
-
The initial segmented outputs from line finding is classified first. The non-fixed pitch text in the remaining text is classified using other word recognition steps.
1. Chopping Joined Characters
-
Tesseract attempts to improve the result by chopping the blob with worst confidence from the character classifier.
-
Chop points are found from concave vertices of a poligonal approximation of the outline, which may have a concave vertex opposite or a line segment. It may take upto 3 pairs of chop points to successfully separate joined characters from ASCII set.
- Chops are executed in priority order. Any chop that fails to improve the confidence of the result is undone, but not completely discarded so that it can be re-used by the associator if needed.
2. Associating Broken Characters
-
After the potential chops have been exhausted, if the word is still not good enough, it is given to the associator, which makes a best first search of the segmentation graph of the possible combinations of the maximally chopped blobs into candidate characters.
-
The search pulls candidate new states from a priority queue and evaluates them by classifying unclassified combinations of fragments.
-
The chop-then-associate method is inefficient but it gives a benefit of simpler data structures that would be required to maintain the full segmentation graph.
- This ability of Tesseract to successfully classify broken characters gave it an edge over the contemporaries.
Static Character Classifier
1. Features
-
Early version of Tesseract used topological features, which are independent of font and size but are not robust to issues found in real-life images.
-
Another idea for classification involved use of segments of the polygonal approximation as features, but this method is also not robust to damaged characters.
-
Solution to these problems lie in the fact that the features in the unknown need not be the same as the features in the training data. During training, segments of a polygonal approximation are used for features, but during recognition, features of a small, fixed length are extracted from the outline and matched many-to-one against the clustered prototype features of the training data.
-
The process of small features matching large prototypes is easily able to cope with recognition of damaged words. It’s main problem is that the computational cost of computing the distance between an unknown and a prototype is very high.
2. Classfication
-
This stage proceeds as a two-step process. First step involves a class pruner that creates a shortlist of character classes that the unknown might match.
-
The classes shortlisted in step one are taken further to the next step, where the actual similarity is calculated from the feature bit vectors. Each prototype character class is represented by a logical sum-of-product expression with each term called a configuration.
3. Training Data
The classifier is trained on a mere 20 samples of 94 characters from 8 fonts in a single size, but with 4 attributes (normal, bold, italic, bold italic), making the total of 60160 training samples.
Linguistic Analysis
-
Whenver the word recognition module is considering a new segmentation, the linguistic model (called permuter) choses the best available word string in the categories: Top frequent word, Top dictionary word, Top numeric word, Top UPPER case word, Top lower case word (with optional initial upper), where the final decision for segmentation is simply the word with the lowest total distance rating.
-
Since words from different segmentations may have different number of characters in them, it would be hard to compare these words directly (even if a classifier claims to produce probabilities, which Tesseract does not).
-
Tesseract instead produces two numbers to solve this issue, namely,
- Confidence, is minus the normalized distance from the prototype. It is confidence in the sense that greater the number better a metric it is.
- Rating is product of normalized distance from the prototype and total outline length in the unknown character.
Adaptive Classifier
-
OCR engines are benefitted from use of an adaptive classifier because the static classifier has to be good at generalizing to any kind of font, its ability to discriminate between different characters or between characters and non-characters is weakened.
-
Tesseract has a font-sensitive adaptive classifier that is trained using the output of the static classifiers which is commonly used to obtain greater discrimination within each document, where the number of fonts is limited.
-
It uses the same features and classifier as the static classifier to train the adaptive classifier. The only significant difference between the two classifiers apart from the training data is that the adaptive classifier uses the isotropic baseline/x-height normalization, whereas the static classifier normalizes the characters by the centroid (first moment) for position, and second moments for anisotropic size normalization.
-
The baseline normalization helps distinguish the upper and lower case characters and also improves immunity to noise specks.
- The main benefit of character moment normalization is removal of font aspect ratio and some degree of font stroke width. It also makes recognition of subscripts and superscripts easier, but requires an additional feature to distinguish the uppercase and lowercase characters.


Manual test to see how do browsers behave when <input … autofocus> is added after the document was loaded
<input … autofocus>


FILM TITLE: BLACK ROBE DIRECTOR: BRUCE BERESFORD COUNTRY: CANADA/AMERICA ( 1991 ) MUSIC: Georges Delerue SUPER FEATURES: SCENERY. GOOD INDIAN STORY, BELIEVE IT OR NOT. CAST: Aiden Young, Sandrine Holt, Lothaire Bluteau
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
I liked THE LAST OF THE MOHICANS, and couldn't resist checking out this film, since I am a bit of a history buff, in film anyway.
The BLACK ROBE is about the first Christian soul drivers to hit Canada in the 16th and 17th Centuries. Some of them made it, because they were honest and cared, but others suffered because they were more forceful and were not used to the way of the Indians in the area.
The main character comes to the new continent and is going to be assigned a tribe that his predecessor could not succeed, and lost an ear because of it. In the process, as he travels to the area where he must go, he makes friends with a thief, who becomes his helper many times. And this thief also gains an affection from an Indian girl, which doesn't sit too well with a few Indians, but she goes her way because she is intelligent, and makes her own decisions. And here the first fault of the Indian is shown, in that he tends to OWN, and dominate the women, and this girl has become westernized in that she has changed.
Through out the film, a few Indians tease the black robed Jesuit priest, who has secretly fallen in love with the same Indian girl, only to find out he has no chance, for which he flogs himself. Another sore point with him is the diminutive medicine man who keeps making fun of the black robed man's beliefs and his moods, only to prove true in the end. The medicine man is harping all the time, and gets out voted once, about the Indians coming to believe another god, or set of beliefs, which will destroy him. In the end, the tribe that wished to be baptized by the black robe, believed that it would absolve them of their 'sins'.....and the film's final caption states that they lived ten more years and were annihilated by their enemies after that, without a fight. This was the point of the little man. He said that the new beliefs would make them lesser men, and that they would lose sight of themselves........and they did.
The film is odd, in that it sticks by the western man's thinking, until it knows that the cause is almost lost, and that the only chance for survival is to join forces as a stronger force. But belief in the westernized God did not make the Indians stronger men, or women, it made them weak, and less of a 'hunter' and 'survivor' in an area where the terrain, the weather, and the opportunities are few to survive by one self.
Aside from being a sad film about the fall of the Indian folklore, belief system, and the rise of the western man in Canada, it is a very well directed, and faithfully represented film, that does not say where the fault lies. A bit on both sides, I guess. The Indians could have learned a few new tricks, but didn't need to change their very own beliefs in life and living, whereas the European counter part accepted nothing but total acceptance, which may have been the real problem.
GOOD FILM FOR HISTORY, IT IS FAITHFUL. 3 GIBLOONS
Copyright (c) Pedro Sena 1994
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


| telnet | pid | 4483 |
| ppid | bash | |
| user | rchateau |
Overview telnet |
|
| Standard process. Uniquely associated to a CIM_ComputerSystem and a parent CIM_Process. |
| CIM_Process | Standard process. Uniquely associated to a CIM_ComputerSystem and a parent CIM_Process. |
| Handle | 4483 |
| <IP_ADDRESS> | Current host:<IP_ADDRESS> |
| telnet | <IP_ADDRESS> | |
| rchateau | ||
| Resident_Set_Size | 2236416 B | |
| Virtual_Memory_Size | 15446016 B | |
| command | telnet <IP_ADDRESS> | |
| pid | 4483 | |
| runs | telnet | |
| user | rchateau |


Location
Id:
23Name:
Earth (C-500A)Tipo:
PlanetDimension:
Dimension C-500AResidents:
['https://rickandmortyapi.com/api/character/37', 'https://rickandmortyapi.com/api/character/91', 'https://rickandmortyapi.com/api/character/176', 'https://rickandmortyapi.com/api/character/183', 'https://rickandmortyapi.com/api/character/195']


--- layout: post title: Sensors, sensors everywhere date: '2021-06-10T09:23:00.001+01:00' author: Tinkerer tags: modified_time: '2021-06-10T09:23:27.112+01:00' ---
Talk about my hardware choices, and why. Things I've learned based on my and other people's experience.
For sensors, I'd stick light and temperature sensors in every room, and motion sensors (or other presence detection) either side of most doorways (so you can work out direction of travel). Every door or window - internal too - would have a door sensor, and any room able to generate humidity (bathrooms, kitchen, etc) would have a humidity sensor
Leak sensors, gas sensors, smoke/heat sensors


Recipe 11.16. Viewing an Image from a URL with Swing and JythonCredit: Joel Lawhead, Chuck Parker ProblemYou want to make a simple Swing image viewer, accepting the URL to an image and displaying the image in a Swing window. SolutionJython makes this task very easy: from pawt import swing from java import net def view(url): frame = swing.JFrame("Image: " + url, visible=1) frame.getContentPane( ).add(swing.JLabel(swing.ImageIcon(net.URL(url)))) frame.setSize(400,250) frame.show( ) if _ _name_ _ == '_ _main_ _': view("http://www.python.org/pics/pythonHi.gif") DiscussionSwing's JLabel and ImageIcon widgets can be easily combined in Jython to make a simple image viewer. The need to pass a URL to the view function is not at all a limitation, because you can always use the file: protocol in your URL if you want to display an image that lives on your filesystem rather than out there on the Web. Remember that the U in URL stands for Universal! See AlsoSwing docs are at http://java.sun.com/docs/books/tutorial/uiswing/; Jython is at http://www.jython.org. |


{% extends 'base.html' %} {% block title %}RAD Remedy - Home{% endblock %} {% block head_text %}RAD Remedy{% endblock %} {% block content %}
RAD Remedy is dedicated to connecting trans, gender non-conforming, intersex, and queer folks to accurate, safe, respectful, and comprehensive care.
Search our national database of providers to find the right resources in your area to fulfill your needs.
{% if logged_in() %} Update your profile to customize your searching options and view reviews tailored to your identities. {% else %} Create an account or sign in to leave reviews, customize your searching options, and view reviews tailored to your identities. {% endif %}
Share your experiences to help others find accurate, safe, respectful, and comprehensive care.
{{ r.location|truncate(40) }}
{%- endif %}


This tool is intended to help beginners create their first character and walk people through the process of
character
creation.
The #1 rule for dnd is to create something that you can be excited about and have fun playing, not to make the
mose
over-powered character you can create. After all - the goal of the game is to have fun, not to gain advantages
over
your team mates.
Choose your class first. This will help decide your characters race. I choose to do this step first because a
characters class is a bigger deciding factor to the style of play your character will follow.
Class list:
Barbarian - Run at people
Bard - Supports people with song
Cleric - Healer from diety
Druid - Tree Hugger/Zoo Summoner
Fighter - Average Soldier with average skills
Monk - Martial arts/Spiritual person
Paladin - Death to all Evil
Ranger - Robin hood (shoot at people)
Rogue - Criminal, basic fiend
Sorcerer - Magic from bloodline
Warlock - Magic from deity
Wizard - Magic from books
Character class -
Base health: {{vm.character.health}}
Health dice: {{vm.character.healthRecovery}} - (sleep regen roll)
Armor: {{vm.character.armor}}
Weapons: {{vm.character.weapons}}
Order your base skill priority. Character skill priorities:
#1 {{vm.character.statPriorityOne}},
#2 {{vm.character.statPriorityTwo}}
{{item.label}}
Class Features
Rage - like the hulk. You can get mad on your turn. Can't Rage if you have heavy armor.
The following applies:
Advantage on strength checks and saving throws.
When you attack(melee), you get bonus damage (increases with barbarian level)
Resistance to bludgeoning, piercing, and slash damage.
Can't cast spells
Rage lasts for 1 minute. Ends early if you are knocked out, or can't attack anything.
Can only rage once until you rest at lvl 1.
Unarmored Defense - while you aren't wearing armor, your AC(armor class) is 10 +
dexterity
modifier + constitution modifier. (shields are ok)
Spell replace - When you level up, you can replace a spell you have with one from the
Bard spell list up to your max level.
Spellcasting Ability - Uses charisma.
Ritual Casting - Any bard spell you know can be cast as a ritual.
Spellcasting Focus - Use a musical instrument for spellcasting focus for bard spells.
Bardic Inspiration - Use this on a teammate to "inspire" them. They get a + 1d6 to use
for any ability check within the next 10 minutes. (can use it after you roll the 1d20). You can
use this at max 1 or your chrisma modifier.
Use Wisdom modifier for Spells
Ritual Casting - Cast a cleric spell as a ritual if prepared and spell has ritual tag.


--- layout: page title: About header-img: "img/about-bg.png" ---
Sometimes, life presents you with an opportunity. "We shall always be QUICK to seize opportunity"!


An ideal frequency inverter is modeled by using a VfController and a three-phase SignalVoltage. Frequency is driven by a load cycle of acceleration, constant speed, deceleration and standstill.
Simulate for 20 seconds and plot (versus time):
Default machine parameters are used.


Structures
The following structures are available globally.
-
A context free or regular grammar consisting of a set of productions
In context free grammars, the left side of productions (in this framework also referred to as pattern) is always a single non-terminal.
Grammars might be ambiguous. For example, the grammar
<expr> ::= <expr> '+' <expr> | 'a'
can recognize the expression
See morea+a+a+a
in 5 different ways:((a+a)+a)+a
,(a+(a+a))+a
,a+(a+(a+a))
,a+((a+a)+a)
,(a+a)+(a+a)
.Declaration
Swift
public struct Grammar
extension Grammar: CustomStringConvertible
extension Grammar: Equatable
extension Grammar: Codable
-
A parser based on the CYK algorithm.
The parser can parse non-deterministic and deterministic grammars. It requires O(n^3) runtime.
For ambiguous grammars, the runtime for parses may increase, as some expressions have exponentially many possible parse trees depending on expression length. This exponential growth can be avoided by only generating a single parse tree with
syntaxTree(for:)
.For unambiguous grammars, the Earley parser should be used instead, as it has linear or quadratic runtime.
The original CYK parsing can only recognize grammars in Chomsky normal form. This parser automatically transforms the recognized grammar into Chomsky normal form and transforms the parse tree back to the original grammar. Nullable items are ommited in the parse tree of the CYK parser.
See moreDeclaration
Swift
public struct CYKParser : AmbiguousGrammarParser
-
A set of terminal or non-terminal symbols
See moreDeclaration
Swift
public struct SymbolSet
-
A string of symbols which can be used in a production of a grammar
See moreDeclaration
Swift
public struct ProductionString
extension ProductionString: ExpressibleByArrayLiteral
-
A string of non-terminal symbols
See moreDeclaration
Swift
public struct NonTerminalString
extension NonTerminalString: Hashable
-
A production result contains multiple possible production strings which can all be generated from a given non-terminal.
A production result can be used when creating a production rule with different possible productions:
See more"A" --> n("B") <|> t("x") ^ generates a production result
Declaration
Swift
public struct ProductionResult
extension ProductionResult: ExpressibleByArrayLiteral
-
A parser generator implementation that internally uses the Earley algorithm.
Creates a syntax tree in O(n^3) worst case run time. For unambiguous grammars, the run time is O(n^2). For almost all LR(k) grammars, the run time is O(n). Best performance can be achieved with left recursive grammars.
For ambiguous grammars, the runtime for parses may increase, as some expressions have exponentially many possible parse trees depending on expression length. This exponential growth can be avoided by only generating a single parse tree with
syntaxTree(for:)
.For unambiguous grammars, the Earley parser performs better than the CYK parser.
See moreDeclaration
Swift
public struct EarleyParser : AmbiguousGrammarParser
-
A syntax error which was generated during parsing or tokenization
See moreDeclaration
Swift
public struct SyntaxError : Error
extension SyntaxError: CustomStringConvertible
-
A production describing what symbols can be generated starting from a given non-terminal pattern
See moreDeclaration
Swift
public struct Production : Codable
extension Production: Hashable
extension Production: CustomStringConvertible
extension Production: CustomDebugStringConvertible
-
A non-terminal symbol, which cannot occurr in a word recognized by a parser
See moreDeclaration
Swift
public struct NonTerminal : Codable, Hashable
extension NonTerminal: CustomStringConvertible
extension NonTerminal: ExpressibleByStringLiteral
-
A simple tokenizer which uses a all terminals in a grammar for tokenization.
Terminals may not overlap partially. If two terminals,
See moreab
andbc
exist andabc
is tokenized, the tokenizer will not find an occurrence of the second terminal.Declaration
Swift
public struct DefaultTokenizer : Tokenizer


This tutorial gives a simple introduction to BOSH. If you never deployed with BOSH or never heard about it this step-by-step guide will bring you up to speed.
Learn more:
We are going to use local BOSH environment provided by VirtualBox (known working version 5.1+). We will install BOSH server (Director) using BOSH CLI. Once VM with Director is running we are going to use BOSH CLI to send commands to the Director.
Learn more:
BOSH CLI is a command line interface to the Director. Follow these instructions to install it.
We are going to use bosh create-env command to install BOSH Director. bosh create-env command provides a way to install initial VM with BOSH Director on any IaaS (AWS, GCP, etc). In our case we will use VirtualBox as our infrastructure provider.
First get configuration files that specify BOSH environment in VirtualBox. And run bosh create-env as following:
In case of any issues see bosh-deployment VirtualBox docs.
Learn more:
Once VM with BOSH Director is running, point your CLI to it, saving the environment with the alias vbox:
Obtain generated password to BOSH Director:
Log in using admin username and generated password:
Now we are ready to deploy!
Before we proceed we need to understand what BOSH needs to deploy software.
Software that is deployed with BOSH needs to be packaged in a special format called a release. For each service that will be deployed, a release needs to contain source files, configuration files, installation scripts, etc. For example, a redis release would contain the source code for redis, redis configuration defaults and redis init scripts.
Each BOSH deployment needs to provide a specially structured configuration file - deployment manifest. This file defines what resources are going to be deployed, what services are going to be running on each of resources and properties that will be passed to services configuration files. For example, for a redis deployment manifest, there are entries for how many and what size redis VMs there should be and how redis should be configured.
Learn more:
We are going to use a simple BOSH release that deploys an http server.
Upload generated release to Director:
Check uploaded releases:
Learn more:
A Stemcell is an operating system image that BOSH uses to create VMs. Official BOSH stemcells are maintained with security updates at bosh.io.
Upload stemcell to Director.
See uploaded stemcells:
Learn more:
Run deploy by providing path to deployment manifest. Deployment manifest specifies what services to deploy, their properties and resources configuration.
See the list of deployed instances as it was specified in manifest:
Add route to VirtualBox network:
See that our service is up and running.
Learn more:
Now we will update our deployment with new version of software. We will modify some properties. And we are going to scale our deployment.
BOSH makes it easy to modify and deploy new versions of software. Let's modify our release source files.
In release folder open src/simple_server/app.rb and change the name to yours.
Create new version of release (force option is used to ignore warning about local changes), upload new version of release to Director and deploy!
See that the updated version was deployed:
With BOSH it is easy to scale deployments. All you need to do is modify number of instances in manifest file.
Open manifest.yml and change number of instances under job from 1 to 2. Add another IP to list of job static IPs: <IP_ADDRESS>.
Run deploy:
Check that 2 instances were deployed:
See that we have 2 instances of our service running:
Every release can specify a set of properties that need to be set in deployment manifest and provided to service. For example, that can be database credentials, address of another service, etc.
Our release allows to change property port on which server is listening. You can see the list of properties that can be modified in learn-bosh-release/jobs/app/spec. Let's open manifest.yml and under the section properties set the value of port to 8888. Now we can just re-deploy our manifest changes. Note, we don't need to build new release version, configuration files will be regenerated with new properties.
Let's see that our property was changed:
BOSH provides a set of recovery mechanisms. Let's break our deployment and find ways to fix it.
BOSH is using monit to monitor running services. If the service goes down it will bring it up. Let's watch how this works. SSH to one of instances:
In a separate window (on host) let's kill our runnning server:
Back in the instance window notice that monit will report process as 'Does not exist' and after some period service will be brought back up by monit again.
Learn more:
What if there is a problem with instance that is running our service? BOSH offers manual and automatic recovery when there are problems with infrastructure resources like VMs or disks. In this exercise we are going to kill one of our instances and use manual recovery option.
Lets destroy one of our instances. SSH to VirtualBox VM.
Our VirtualBox environment is using Warden to manage resources. Warden is a Linux container management tool. Each container represents one instance.
Let's see that one of the instances is in a bad state:
One of the components in BOSH is the Health Monitor. It independently watches system health and will bring missing instances back up by instructing infrastructure to recreate missing resources like VMs with the required persistent disk. Keep running bosh -e vbox instances and see that instance is brought up and service is running eventually.
Now let's turn off automatic repair and manually resolve the issue.
Kill one of the containers again as described above. Run cloud check and select option "Recreate VM and wait for processes to start".
Cloud check command allows to manually resolve issues when resources (VMs and persistent disks) are in a bad state. Run bosh -e vbox instances to see all instances running again.
Learn more:
When deploy command fails there are could be a number of reasons:
Let's add another job to our manifest router (it will redirect all requests between servers). Note, that since uploaded release already contains this job, we don't need to update release.
Re-deploy with new job.
Oh-oh, looks like deploy failed. Let's get our service logs, untar them and check stderr log.
We should find this error: "At least one server must be provided". Router fails to route because there is no servers specified.
Let's add a property to router job to specify our servers pointing to their static IPs and ports ("http://<IP_ADDRESS>:8888", "http://<IP_ADDRESS>:8888"), re-deploy and see it succeeds.
Now running curl -L http://<IP_ADDRESS>:8080 should give us responses from different servers.
In this tutorial we used BOSH to deploy services, updated our deployment with source changes, scaled the number of services and changed their properties. We recovered from failing service, failing VM and failing deploy.
We were using VirtualBox environment with Warden CPI (Cloud Provider Interface). Warden is a Linux container management tool and Warden CPI abstracts VMs as Linux containers. The Director can work with any CPI that implements a certain API to manage IaaS resources. There are several supported CPIs for different IaaS providers: AWS, GCP, Openstack, vSphere and vCloud. Read more about CPIs here: http://bosh.io/docs/cpi-api-v1.html.
Learn more:


Offical OWSLA Sound
Skrillex Drum Kit
A
clap
S
hihat
D
kick
F
openhat
G
boom
H
ride
J
snare
K
tom
L
tink
Z
SRX
X
SRX
C
SRX
V
SRX!
B
SRX!
N
SRX!
M
SRX!


--- layout: post title: Nicholas presents the Directors categories: - horizon author: admin published: true date: 2005-01-06 23:02:09.000000000 +00:00 ---
Nicholas Seckar is busy working away on the Directors — the next-generation URL mapping scheme for Rails — yet still took the time to explain how its going to work. Of course, he chose to use the newly launched SoapBX: Rails & Rewriting. Most excellent.


elixush v0.0.4 Elixush.Interpreter
Summary
Functions
Executes the contents of the exec stack, aborting prematurely if execution limits are exceeded. The resulting push state will map :termination to :normal if termination was normal, or :abnormal otherwise
Executes a single Push instruction
Functions
Executes the contents of the exec stack, aborting prematurely if execution limits are exceeded. The resulting push state will map :termination to :normal if termination was normal, or :abnormal otherwise.


First of all this blog post on xcode server helps a lot.
I followed the tutorial that apple offers inside of the OS X Server Application. Since i use ssh for authentication for my private github repositories i needed upload my public key to github. That for some reason didn't work so i generated a new ssh key inside of the OS X Server Application. And uploaded that new public key. Then it worked but xcode gave me an error for the readme.md file. Removing it and adding it again through the Xcode UI fixed that. Then everything worked. :) .
Happy Coding