--- layout: post authors: ["Adina Howe"] title: "Help Software Carpentry's Strategic Planning" date: 2015-07-18 time: "21:00:00" tags: ["Steering Committee", "Software Carpentry Foundation"] ---
The SCF Steering Committee is undertaking a strategic planning process that will help us to identify the SCF's working priorities for short- and long-term success, based on input from you.
Your input is crucial—we are beginning the process by asking that you identify key Strengths, Weaknesses, Opportunities, and Threats (SWOT) facing SCF over the next five years via this anonymous survey. We will review the survey results, summarize key issues, and develop a summary and plan that addresses the issues raised.
To help, please fill in the SWOT Survey. Note that the survey asks for 3 answers for each strengths, weaknesses, opportunities, and threats but you may fill out more or less as you see fit. Please fill out the survey only once and by August 5, 2015.
For SWOT responses, it would be most helpful if they are text provided as one answer per line. For example, an answer could be:
Coffee is fantastic
Candy is tasty
Volunteers are handy
Thank you for your help!


Hong Kong leader Carrie Lam says about 600 protesters have left university campus surrounded by ...
HONG KONG - HONG KONG (AP) - Hong Kong leader Carrie Lam says about 600 protesters have left university campus surrounded by police, about 100 remain.
Copyright 2019 The Associated Press. All rights reserved. This material may not be published, broadcast, rewritten or redistributed.


The DBM Google Sheets add-on = ADDON_TITLE ?> is set to run automatically to sync DBM reports. The add-on was recently updated and it needs you to re-authorize it to run on your behalf.
The add-on's automatic functions are temporarily disabled until you re-authorize it. To do so, open Google Sheets and run the add-on from the Add-ons menu. Alternatively, you can click this link to authorize it:
This notification email will be sent to you at most once per day until the add-on is re-authorized.


with ZipFile(path, "r") as zip_file:
print(zip_file.namelist())
type, save_attributes = cls._load_pickle(zip_file, "config").values()
loaded_object = type.__new__(type)
for att, method in save_attributes.items():
if not path.exists():
raise ValueError("Path to load agent is not valid")
with ZipFile(path, "r") as zip_file:
loaded_object = cls.load_zip(zip_file)
return loaded_object
@classmethod
def load_zip(cls, zip_file, folder=""):


{% extends "front/base_docs.html"%} {% load static%} {% block title%} Help videos - healthchecks.io {% endblock%} {%block docs_content%} {% include "help_videos/modals.html" %}
It's empty in here {% if request.user.is_superuser%} Click here to add{% endif %}


{% extends "surveyinterface/base.html" %} {% load staticfiles %} {% block body %}
The Survey Data Viewer is a web application for visualizing the results of social science survey data developed as part of the iUTAH Modeling and Data Federation (http://data.iutahepscor.org). For the code and additional documentation, see http://github.com/UCHIC/SurveyDataViewer. The code may be adopted for general use following the stipulations in the code repository (https://github.com/UCHIC/SurveyDataViewer/blob/master/LICENSE).


The bison are late. They were scheduled to arrive two hours ago at the Crane Trust, but it’s tricky convincing a herd of 42 wild plains bison to get into a truck trailer, and then drive for five and a half hours from Crawford in northwest Nebraska to Grand Island in central Nebraska. But the trucks have just arrived, right before sunset.
“Well, I came because my friend told me about it! We were interested, the kids have always been interested in that kind of thing so I brought my grandchildren out,” Cathy Stoddard from Grand Island is one of a crowd of about 60 standing outside the bison corral.
The door to the trailer opens, and one very large bison is sitting at the end of the trailer, with her legs tucked under her body. The crowd murmurs an, “aww” and, after a few minutes, the bison gets up and leaves the truck for the open corral.
There’s something special about these bison, from Rimrock Ranch in Crawford. They have never interbred with domestic cattle. 95 percent of the bison in the US are mixed with cattle. The herd at the Crane Trust are some of the bison-iest plains bison you can find.
It takes the handlers a few minutes to convince the rest of the bison to leave the trailer. Caroline Wicks lives in Grand Island and is watching with her hands pressed against the corral fencing.
“There’s a variety of sizes. I’m sure ages. Maybe some of those are older, some are younger, there’s some babies over there. They’re just beautiful,” Wicks said.
Bison were extirpated from central Nebraska in the late 1800s. Today, these purebred bison are being welcomed back to one of the few places where there’s still unplowed prairie.
“The trust owns title to Mormon Island which is this pasture to the east of us here is the largest remaining mid and tallgrass prairie in the state of Nebraska. These buffalo that are coming are gonna think they died and gone to heaven,” Tom Dougherty, board member for the Crane Trust, said.
Plains bison aren’t endangered, but there are far fewer of them today than in the 19th century. One of the biggest efforts to restore bison has been through a partnership between the Inter Tribal Bison Cooperative and the National Wildlife Federation. They’ve worked together since the 1980s to move overflow wild plains bison from Yellowstone to tribal reservations.
Outside, once the bison have had the chance to investigate the corral, Dougherty introduces his friend Louis LaRose. “Louie’s been a very dear friend of mine for many many years, and has forgot more about buffalo than I’ll even know. He would like to say a prayer.”
LaRose steps up next to his friend and addresses the crowd before turning to the corral. “I talked to the buffalo and told them they were home, and not be afraid. This is a new environment. Now I’m gonna pray with them. This time I’m not talking to the buffalo, I’m talking to the Creator.”
The two men worked together when Dougherty was with the National Wildlife Federation and LaRose was the president of the Inter Tribal Bison Cooperative. While president, LaRose saw bison introduced to tribal reservations, including the Winnebago reservation in northeast Nebraska. LaRose is always excited to see bison return to a place they used to be.
“After you work with bison, you begin to change. Your attitudes, your thoughts about bison. I came to understand that they’re a highly intelligent animal that the creator put them here for a purpose, same as he put man on earth for his purpose. And we were meant to be together,” LaRose said.
But no one actually knows what would happen – ecologically — to the prairie if bison came back.
“The science staff here said we really should see what bison mean to the habitat. What are the benefits or detractions as it relates to waterfowl and cranes,” Dougherty said that this was one of the reasons the Trust brought this herd of bison to Grand Island.
That study is going to take place over the next five years. For now, Crane Trust President Chuck Cooper seems to be just enjoying having the bison here finally.
“I got a little emotional. Because it’s, when you see ‘em, you can’t help but just be in wonder. I mean they’re prehistoric animals. And the fact that they’re still here and now that they’re back here. This will be the largest public herd within 200 miles in any direction,” Cooper said.
And so are many of their neighbors. Cathy Stoddard and her granddaughter Samantha Hansen are still watching the bison, despite the temperature dropping with the sunset.
“We got here just as some had already been unloaded. I thought they were probably tired and ready to get off the truck,” Stoddard said. Her granddaughter pipes up, “I wanna pet one!”
Asked if she meant to touch or to own as a pet, she replied, “Both!”
In a little less than two months, the bison have settled into their new home in central Nebraska. In mid-March, the Crane Trust moved the bison from the corral to a 200-300 acre enclosed pasture.
Correction: An earlier version of this story stated it had been 200 years since bison were on the central Platte. It is closer to 150 years.


Hi there, I'm Jiyan GUO.
I graduated from SUPINFO International University with master's degree in Nov. 2011, and from Université Paris XII with master's degree of Biometric in Sep. 2013.
I've been working on web-based projects for years. I'm now an IT DEV Engineer in the Visa Center of French Embassy in China, mainly use PHP and its related techologies (Javascript, Bash script, etc.). I started using PHP since 2008, and am certified as a Zend Certified Engineer by ZEND.com in 2010. For the server management, I'm used to working on CentOS or Ubuntu platforms. Besides PHP, I also learned python and had a glimpse of some other interesting languages.
Usually I spend my spare time on traveling, reading etc. to find interesting things. I'm always interested in challenging and creative things or ideas. But of course, I prefer traveling :-D.
Oh! BTW, you are welcome to view my skills & experiences in the other pages in the navigation menu. If you find some common interests that you'd like to discuss, please contact me via<EMAIL_ADDRESS>Enjoy ;-).
Yann
In charge of building the information system for automobile service shops of the company. Following up the shops' business requirements since the beginning of the project, participating product planning and system architecture design. Achieved the integrated management of differentiated services over all shops, the centralized monitoring of shops' operation status, and other requirements like collecting consumer information; by introducing WeChat, successfully directed the user traffics from physical shops to the online shop. The latter job is mainly on system docking, designing the data exchange API, building data link for datacenter and the ACI equipments deployed in shops. Achieved to collect car info remotely and automatically, so the system can provide basic data for the further client behavior analysis etc.
Worked in system development team of the Visa Center of French Embassy in China. Developing and maintaining the visa application system for french consulate, performing technical evaluation for change requirements from global visa centers and implementing the validated changes. Mainly responsible for the Application Submission, Progress Monitoring and Authorization modules. Using Redis to implement sticky session among multiple server nodes. Used Ubuntu Desktop as working environment, Git for version control, and JIRA for issue tracking.
In charge of developing the mail subscription service platform. Performing requirement analysis, based on Yii framework, achieved batch user importing, template-based content generation, massive mail distribution and other functionalities. Designed solution to solve the exclusive reading/writing of concurrent processes on the email queue in database. The system sends 200K-400K emails per day. The mail distribution solution was later hosted on GitHub as open-source project.
A ready-to-use module gives enhanced maintenance mode to a yii 2.0 website. It provides different Blocking Modes, with some enhanced features: Alpha Test Authencation, News Ticker, etc.
The idea is to easily give the development team an opportunity to test their new changes on live site, without "surprising" public users. And also to allow them to verify the results that are not effected by operations from the public.
A yii2.0 based, highly configurable multi-process emailing solution (console command), which can process 100,000 emails within 9 minutes.
The solution is implemented as a console command of yii framework 2.0, with a group of management pages. The console program is designed to be able to send an email queue parallelly, and also be able to distributed easily on multiple servers, in case single server is not powerful enough to handle the emailing job.
This extension can be easily installed by it's installer. And thanks to the well structured framework, it can also be integrated to an existing system within 5 minutes, just by configuring a few parameters.


Module datasist.visualizations
This module contains functions that can help you create aesthetic and colorful plots with minimal codes
Expand source code
'''
This module contains all functions relating to visualization.
'''
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from . import structdata
from IPython.display import display
from sklearn.metrics import confusion_matrix
from sklearn.utils.multiclass import unique_labels
import sklearn.metrics as sklm
def countplot(data=None, features=None, separate_by=None, fig_size=(5,5), save_fig=False):
'''
Makes a bar plot of all categorical features to show their counts.
Parameters
------------
data : DataFrame, array, or list of arrays.
The data to plot.
features: str, scalar, array, or list.
The categorical features in the dataset, if not provided,
we try to infer the categorical columns from the dataframe.
separate_by: str, default None.
The feature used to seperate the plot. Called hue in seaborn.
fig_size: tuple, Default (5,5)
The size of the figure object.
save_fig: bool, Default False.
Saves the plot to the current working directory
Returns
-------
None
'''
if data is None:
raise ValueError("data: Expecting a DataFrame or Series, got 'None'")
if features is None:
features = structdata.get_cat_feats(data)
for feature in features:
#Check the size of categories in the feature: Anything greater than 20 is not plotted
if len(data[feature].unique()) > 30:
print("Unique Values in {} is too large to plot".format(feature))
print('\n')
else:
fig = plt.figure(figsize=fig_size)
ax = fig.gca()
sns.countplot(x=feature, hue=separate_by, data=data)
plt.xticks(rotation=90)
ax.set_title("Count plot for " + feature)
if save_fig:
plt.savefig('Countplot_{}'.format(feature))
def plot_missing(data=None):
'''
Plots the data as a heatmap to show missing values
Parameters
----------
data: DataFrame, array, or list of arrays.
The data to plot.
'''
if data is None:
raise ValueError("data: Expecting a DataFrame or Series, got 'None'")
sns.heatmap(data.isnull(), cbar=True)
plt.show()
def boxplot(data=None, num_features=None, target=None, fig_size=(5,5), large_data=False, save_fig=False):
'''
Makes a box plot of all numerical features against a specified categorical target column.
A box plot (or box-and-whisker plot) shows the distribution of quantitative
data in a way that facilitates comparisons between variables or across
levels of a categorical variable. The box shows the quartiles of the
dataset while the whiskers extend to show the rest of the distribution,
except for points that are determined to be "outliers" using a method
that is a function of the inter-quartile range
Parameters
------------
data : DataFrame, array, or list of arrays.
Dataset for plotting.
num_features: Scalar, array, or list.
The numerical features in the dataset, if not None,
we try to infer the numerical columns from the dataframe.
target: array, pandas series, list.
A categorical target column. Maximun number of categories is 10 and minimum is 1
fig_size: tuple, Default (8,8)
The size of the figure object.
large_data: bool, Default False.
If True, then sns boxenplot is used instead of normal boxplot. Boxenplot is
better for large dataset.
save_fig: bool, Default False.
If True, saves the current plot to the current working directory
'''
if target is None:
raise ValueError('Target value cannot be None')
if len(data[target].unique()) > 10:
raise AttributeError("Target categories must be less than 10")
if data is None:
raise ValueError("data: Expecting a DataFrame or Series, got 'None'")
if num_features is None:
num_features = structdata.get_num_feats(data)
if large_data:
#use advanced sns boxenplot
for feature in num_features:
fig = plt.figure(figsize=fig_size)
ax = fig.gca()
sns.set_style("whitegrid")
sns.boxenplot(target, feature, data=data, ax=ax)
plt.ylabel(feature) # Set text for the x axis
plt.xlabel(target)# Set text for y axis
plt.xticks(rotation=90)
plt.title('Box plot of {} against {}'.format(feature, target))
if save_fig:
plt.savefig('fig_{}_vs_{}'.format(feature,target))
plt.show()
else:
for feature in num_features:
fig = plt.figure(figsize=fig_size)
ax = fig.gca()
sns.set_style("whitegrid")
sns.boxplot(target, feature, data=data, ax=ax)
plt.ylabel(feature) # Set text for the x axis
plt.xlabel(target)# Set text for y axis
plt.xticks(rotation=90)
plt.title("Box plot of '{}' vs. '{}'".format(feature, target))
if save_fig:
plt.savefig('fig_{}_vs_{}'.format(feature,target))
plt.show()
def violinplot(data=None, num_features=None, target=None, fig_size=(5,5), save_fig=False):
'''
Makes a violin plot of all numerical features against a specified categorical target column.
A violin plot plays a similar role as a box and whisker plot. It shows the
distribution of quantitative data across several levels of one (or more)
categorical variables such that those distributions can be compared. Unlike
a box plot, in which all of the plot components correspond to actual
datapoints, the violin plot features a kernel density estimation of the
underlying distribution.
Parameters
------------
data : DataFrame, array, or list of arrays.
Dataset for plotting.
num_features: Scalar, array, or list.
The numerical features in the dataset, if not None,
we try to infer the numerical columns from the dataframe.
target: array, pandas series, list.
A categorical target column. Maximun number of categories is 10 and minimum is 1.
fig_size: tuple, Default (8,8)
The size of the figure object.
save_fig: bool, Default False.
If True, saves the current plot to the current working directory
'''
if target is None:
raise ValueError('Target value cannot be None')
if len(data[target].unique()) > 10:
raise AttributeError("Target categories must be less than 10")
if data is None:
raise ValueError("data: Expecting a DataFrame or Series, got 'None'")
if num_features is None:
num_features = structdata.get_num_feats(data)
for feature in num_features:
fig = plt.figure(figsize=fig_size)
ax = fig.gca()
sns.set_style("whitegrid")
sns.violinplot(target, feature, data=data, ax=ax)
plt.xticks(rotation=90)
plt.ylabel(feature) # Set text for the x axis
plt.xlabel(target)# Set text for y axis
plt.title("Violin plot of '{}' vs. '{}'".format(feature, target))
if save_fig:
#TODO Add function to save to a specified directory
plt.savefig('fig_{}_vs_{}'.format(feature,target))
plt.show()
def histogram(data=None, num_features=None, bins=None, show_dist_type=False, fig_size=(5,5), save_fig=False):
'''
Makes an histogram plot of all numerical features.
Helps to show univariate distribution of the features.
Parameters
------------
data : DataFrame, array, or list of arrays.
Dataset for plotting.
num_features: Scalar, array, or list.
The numerical features in the dataset, if not None,
we try to infer the numerical columns from the dataframe.
bins: int
The number of bins to use.
show_dist_type: bool, Default False
If True, Calculates the skewness of the data and display one of (Left skewed, right skewed or normal)
fig_size: tuple, Default (8,8).
The size of the figure object.
save_fig: bool, Default False.
If True, saves the current plot to the current working directory
'''
if data is None:
raise ValueError("data: Expecting a DataFrame or Series, got 'None'")
if num_features is None:
num_features = structdata.get_num_feats(data)
for feature in num_features:
fig = plt.figure(figsize=fig_size)
ax = fig.gca()
sns.distplot(data[feature].values, ax=ax, bins=bins)
ax.set_xlabel(feature) # Set text for the x axis
ax.set_ylabel('Count')# Set text for y axis
if show_dist_type:
##TODO Add Code to calculate skewness
pass
else:
ax.set_title('Histogram of ' + feature)
if save_fig:
#TODO Add function to save to a user specified directory
plt.savefig('fig_hist_{}'.format(feature))
plt.show()
def catbox(data=None, cat_features=None, target=None, fig_size=(10,5), save_fig=False):
'''
Makes a side by side bar plot of all categorical features against a categorical target feature.
Parameters
------------
data: DataFrame, array, or list of arrays.
Dataset for plotting.
cat_features: Scalar, array, or list.
The categorical features in the dataset, if None,
we try to infer the categorical columns from the dataframe.
target: Scalar, array or list.
Categorical target to plot against.
fig_size: tuple, Default (12,6)
The size of the figure object.
save_fig: bool, Default False.
If True, saves the plot to the current working directory.
'''
if data is None:
raise ValueError("data: Expecting a DataFrame or Series, got 'None'")
if cat_features is None:
cat_features = structdata.get_cat_feats(data)
#remove target from cat_features
try:
cat_features.remove(target)
except:
pass
if len(data[target].unique()) > 8:
#TODO Plot only a subset of the features say top 10
raise AttributeError("Target categories must be less than seven")
#Create a dummy column to hold count of values
data['dummy_count'] = np.ones(shape = data.shape[0])
#Loop over each categorical feature and plot the rate for each category.
for feature in cat_features:
#Plots are made for only categories with less than 15 unique values because of speed
if len(data[feature].unique()) > 15 :
print("{} feature has too many categories and will not be ploted".format(feature))
else:
counts = data[['dummy_count', target, feature]].groupby([target, feature], as_index = False).count()
#get the categories
cats = list(data[target].unique())
if len(cats) > 6:
raise ValueError("Target column: '{}' must contain less than six unique classes".format(target))
#create new figure
_ = plt.figure(figsize = fig_size)
for i, cat in enumerate(cats):
plt.subplot(1, len(cats), i+1)
#Get the counts each category in target
temp = counts[counts[target] == cat][[feature, 'dummy_count']]
sns.barplot(x=feature, y='dummy_count', data=temp)
plt.xticks(rotation=90)
plt.title('Counts for {} \n class {}'.format(feature, cat))
plt.ylabel('count')
plt.tight_layout(2)
if save_fig:
plt.savefig('fig_catbox_{}'.format(feature))
#Drop the dummy_count column from data
data.drop(['dummy_count'], axis=1, inplace = True)
def class_count(data=None, features=None, plot=False, save_fig=False):
'''
Displays the number of classes in a categorical feature.
Parameters:
data: Pandas DataFrame or Series
Dataset for plotting.
features: Scalar, array, or list.
The categorical features in the dataset, if None,
we try to infer the categorical columns from the dataframe.
plot: bool, Default False.
Plots the class counts as a barplot
save_fig: bool, Default False.
Saves the plot to the current working directory.
'''
if data is None:
raise ValueError("data: Expecting a DataFrame or Series, got 'None'")
if features is None:
features = structdata.get_cat_feats(data)
for feature in features:
if data[feature].nunique() > 15:
print("Unique classes in {} too large".format(feature))
else:
print('Class Count for', feature)
display(pd.DataFrame(data[feature].value_counts()))
if plot:
countplot(data, features, save_fig=save_fig)
def scatterplot(data=None, num_features=None, target=None, separate_by=None, fig_size=(5,5), save_fig=False):
'''
Makes a scatter plot of numerical features against a numerical target.
Helps to show the relationship between features.
Parameters
------------
data : DataFrame, array, or list of arrays.
The data to plot.
num_features: int/floats, scalar, array, or list.
The numeric features in the dataset, if not provided,
we try to infer the numeric columns from the dataframe.
target: int/float, scalar, array or list.
Numerical target feature to plot against.
separate_by: str, default None.
The feature used to seperate the plot. Called hue in seaborn.
fig_size: tuple, Default (10,10)
The size of the figure object.
save_fig: bool, Default False.
Saves the plot to the current working directory
'''
if data is None:
raise ValueError("data: Expecting a DataFrame or Series, got 'None'")
if separate_by is None:
pass
elif separate_by not in data.columns:
raise ValueError("{} not found in data columns".format(separate_by))
if target is None:
raise ValueError('Target value cannot be None')
if num_features is None:
num_features = structdata.get_num_feats(data)
for feature in num_features:
fig = plt.figure(figsize=fig_size) # define plot area
ax = fig.gca() # define axis
sns.scatterplot(x=feature, y=target, data=data, hue=separate_by)
ax.set_title("Scatter Plot of '{}' vs. '{}' \n Separated by: '{}'".format(feature, target, separate_by))
if save_fig:
plt.savefig('fig_scatterplot_{}'.format(feature))
def plot_confusion_matrix(y_true, y_pred, classes,
normalize=False,
title=None,
cmap=plt.cm.Blues):
"""
This function prints and plots the confusion matrix.
Normalization can be applied by setting `normalize=True`.
Parameters:
"""
if not title:
if normalize:
title = 'Normalized confusion matrix'
else:
title = 'Confusion matrix, without normalization'
# Compute confusion matrix
cm = confusion_matrix(y_true, y_pred)
# Only use the labels that appear in the data
classes = classes[unique_labels(y_true, y_pred)]
if normalize:
cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
print("Normalized confusion matrix")
else:
print('Confusion matrix, without normalization')
print(cm)
fig, ax = plt.subplots()
im = ax.imshow(cm, interpolation='nearest', cmap=cmap)
ax.figure.colorbar(im, ax=ax)
# We want to show all ticks...
ax.set(xticks=np.arange(cm.shape[1]),
yticks=np.arange(cm.shape[0]),
# ... and label them with the respective list entries
xticklabels=classes, yticklabels=classes,
title=title,
ylabel='True label',
xlabel='Predicted label')
# Rotate the tick labels and set their alignment.
plt.setp(ax.get_xticklabels(), rotation=45, ha="right",
rotation_mode="anchor")
# Loop over data dimensions and create text annotations.
fmt = '.2f' if normalize else 'd'
thresh = cm.max() / 2.
for i in range(cm.shape[0]):
for j in range(cm.shape[1]):
ax.text(j, i, format(cm[i, j], fmt),
ha="center", va="center",
color="white" if cm[i, j] > thresh else "black")
fig.tight_layout()
return ax
def plot_auc(labels, predictions):
'''
Computes and plot the false positive rate, true positive rate and threshold along with the AUC
Parameters:
--------------------
labels:
This is the true value ( in the case of binary either 0 or 1)
predictions:
This is the probability that shows the likelihood of a value being 0 or 1
Return:
plots the Receiver operating characteristics.
'''
fpr, tpr, threshold = sklm.roc_curve(labels, predictions)
auc = sklm.auc(fpr, tpr)
## Plot the result
plt.title('Receiver Operating Characteristic')
plt.plot(fpr, tpr, color='orange', label='AUC = %0.2f' % auc)
plt.legend(loc='lower right')
plt.plot([0, 1], [0, 1], 'r--')
plt.xlim([0, 1])
plt.ylim([0, 1])
plt.ylabel('True Positive Rate')
plt.xlabel('False Positive Rate')
plt.show()
def plot_scatter_shape(data = None, cols = None, shape_col = '', col_y = '', alpha = 0.2):
'''
Makes a scatter plot of data using shape_col as seperation.
Parameter:
data: Dataframe
The data that is being imported using pandas.
cols: list
The chosen number of columns in the DataFrame.
shape_col:
The categorical column you want it to show as legend.
col_y: The y axis of the plot
Return:
Matplotlib figure
'''
# pick distinctive shapes
shapes = ['+', 'o', 's', 'x', '^']
unique_cats = data[shape_col].unique()
# loop over the columns to plot
for col in cols:
sns.set_style("whitegrid")
# loop over the unique categories
for i, cat in enumerate(unique_cats):
temp = data[data[shape_col] == cat]
sns.regplot(col, col_y, data=temp, marker = shapes[i], label = cat,
scatter_kws={"alpha":alpha}, fit_reg = False, color = 'blue')
# Give the plot a main title
plt.title('Scatter plot of ' + col_y + ' vs. ' + col)
# Set text for the x axis
plt.xlabel(col)
# Set text for y axis
plt.ylabel(col_y)
plt.legend()
plt.show()
def autoviz(data):
'''
Automatically visualize a data set. If dataset is large, autoViz uses a statistically valid sample for plotting.
Parameter:
--------------------
data: Dataframe
The data to plot
Return:
Matplotlib figure
'''
#First check if autoviz is installed, if not installed, prompt the user to install it.
import importlib.util
import logging
logging.basicConfig()
package_name = 'autoviz'
err_msg = "is not installed, to use this function, you must install " + package_name + ". \n To install, use 'pip install autoviz'"
package_stat = importlib.util.find_spec(package_name)
if package_stat is None:
logging.error(package_name + " " + err_msg)
else:
from autoviz.AutoViz_Class import AutoViz_Class
av = AutoViz_Class()
av.AutoViz(filename='', dfte=data, max_cols_analyzed=50)
Functions
def autoviz(data)
-
Automatically visualize a data set. If dataset is large, autoViz uses a statistically valid sample for plotting. Parameter:
data: Dataframe The data to plot
Return
Matplotlib figure
Expand source code
def autoviz(data): ''' Automatically visualize a data set. If dataset is large, autoViz uses a statistically valid sample for plotting. Parameter: -------------------- data: Dataframe The data to plot Return: Matplotlib figure ''' #First check if autoviz is installed, if not installed, prompt the user to install it. import importlib.util import logging logging.basicConfig() package_name = 'autoviz' err_msg = "is not installed, to use this function, you must install " + package_name + ". \n To install, use 'pip install autoviz'" package_stat = importlib.util.find_spec(package_name) if package_stat is None: logging.error(package_name + " " + err_msg) else: from autoviz.AutoViz_Class import AutoViz_Class av = AutoViz_Class() av.AutoViz(filename='', dfte=data, max_cols_analyzed=50)
def boxplot(data=None, num_features=None, target=None, fig_size=(5, 5), large_data=False, save_fig=False)
-
Makes a box plot of all numerical features against a specified categorical target column.
A box plot (or box-and-whisker plot) shows the distribution of quantitative data in a way that facilitates comparisons between variables or across levels of a categorical variable. The box shows the quartiles of the dataset while the whiskers extend to show the rest of the distribution, except for points that are determined to be "outliers" using a method that is a function of the inter-quartile range
Parameters
data : DataFrame, array, or list of arrays. Dataset for plotting. num_features: Scalar, array, or list. The numerical features in the dataset, if not None, we try to infer the numerical columns from the dataframe. target: array, pandas series, list. A categorical target column. Maximun number of categories is 10 and minimum is 1 fig_size: tuple, Default (8,8) The size of the figure object. large_data: bool, Default False. If True, then sns boxenplot is used instead of normal boxplot. Boxenplot is better for large dataset. save_fig: bool, Default False. If True, saves the current plot to the current working directory
Expand source code
def boxplot(data=None, num_features=None, target=None, fig_size=(5,5), large_data=False, save_fig=False): ''' Makes a box plot of all numerical features against a specified categorical target column. A box plot (or box-and-whisker plot) shows the distribution of quantitative data in a way that facilitates comparisons between variables or across levels of a categorical variable. The box shows the quartiles of the dataset while the whiskers extend to show the rest of the distribution, except for points that are determined to be "outliers" using a method that is a function of the inter-quartile range Parameters ------------ data : DataFrame, array, or list of arrays. Dataset for plotting. num_features: Scalar, array, or list. The numerical features in the dataset, if not None, we try to infer the numerical columns from the dataframe. target: array, pandas series, list. A categorical target column. Maximun number of categories is 10 and minimum is 1 fig_size: tuple, Default (8,8) The size of the figure object. large_data: bool, Default False. If True, then sns boxenplot is used instead of normal boxplot. Boxenplot is better for large dataset. save_fig: bool, Default False. If True, saves the current plot to the current working directory ''' if target is None: raise ValueError('Target value cannot be None') if len(data[target].unique()) > 10: raise AttributeError("Target categories must be less than 10") if data is None: raise ValueError("data: Expecting a DataFrame or Series, got 'None'") if num_features is None: num_features = structdata.get_num_feats(data) if large_data: #use advanced sns boxenplot for feature in num_features: fig = plt.figure(figsize=fig_size) ax = fig.gca() sns.set_style("whitegrid") sns.boxenplot(target, feature, data=data, ax=ax) plt.ylabel(feature) # Set text for the x axis plt.xlabel(target)# Set text for y axis plt.xticks(rotation=90) plt.title('Box plot of {} against {}'.format(feature, target)) if save_fig: plt.savefig('fig_{}_vs_{}'.format(feature,target)) plt.show() else: for feature in num_features: fig = plt.figure(figsize=fig_size) ax = fig.gca() sns.set_style("whitegrid") sns.boxplot(target, feature, data=data, ax=ax) plt.ylabel(feature) # Set text for the x axis plt.xlabel(target)# Set text for y axis plt.xticks(rotation=90) plt.title("Box plot of '{}' vs. '{}'".format(feature, target)) if save_fig: plt.savefig('fig_{}_vs_{}'.format(feature,target)) plt.show()
def catbox(data=None, cat_features=None, target=None, fig_size=(10, 5), save_fig=False)
-
Makes a side by side bar plot of all categorical features against a categorical target feature.
Parameters
data: DataFrame, array, or list of arrays. Dataset for plotting. cat_features: Scalar, array, or list. The categorical features in the dataset, if None, we try to infer the categorical columns from the dataframe. target: Scalar, array or list. Categorical target to plot against. fig_size: tuple, Default (12,6) The size of the figure object. save_fig: bool, Default False. If True, saves the plot to the current working directory.
Expand source code
def catbox(data=None, cat_features=None, target=None, fig_size=(10,5), save_fig=False): ''' Makes a side by side bar plot of all categorical features against a categorical target feature. Parameters ------------ data: DataFrame, array, or list of arrays. Dataset for plotting. cat_features: Scalar, array, or list. The categorical features in the dataset, if None, we try to infer the categorical columns from the dataframe. target: Scalar, array or list. Categorical target to plot against. fig_size: tuple, Default (12,6) The size of the figure object. save_fig: bool, Default False. If True, saves the plot to the current working directory. ''' if data is None: raise ValueError("data: Expecting a DataFrame or Series, got 'None'") if cat_features is None: cat_features = structdata.get_cat_feats(data) #remove target from cat_features try: cat_features.remove(target) except: pass if len(data[target].unique()) > 8: #TODO Plot only a subset of the features say top 10 raise AttributeError("Target categories must be less than seven") #Create a dummy column to hold count of values data['dummy_count'] = np.ones(shape = data.shape[0]) #Loop over each categorical feature and plot the rate for each category. for feature in cat_features: #Plots are made for only categories with less than 15 unique values because of speed if len(data[feature].unique()) > 15 : print("{} feature has too many categories and will not be ploted".format(feature)) else: counts = data[['dummy_count', target, feature]].groupby([target, feature], as_index = False).count() #get the categories cats = list(data[target].unique()) if len(cats) > 6: raise ValueError("Target column: '{}' must contain less than six unique classes".format(target)) #create new figure _ = plt.figure(figsize = fig_size) for i, cat in enumerate(cats): plt.subplot(1, len(cats), i+1) #Get the counts each category in target temp = counts[counts[target] == cat][[feature, 'dummy_count']] sns.barplot(x=feature, y='dummy_count', data=temp) plt.xticks(rotation=90) plt.title('Counts for {} \n class {}'.format(feature, cat)) plt.ylabel('count') plt.tight_layout(2) if save_fig: plt.savefig('fig_catbox_{}'.format(feature)) #Drop the dummy_count column from data data.drop(['dummy_count'], axis=1, inplace = True)
def class_count(data=None, features=None, plot=False, save_fig=False)
-
Displays the number of classes in a categorical feature.
Parameters
data
-
Pandas DataFrame or Series
Dataset for plotting.
features
-
Scalar, array, or list.
The categorical features in the dataset, if None, we try to infer the categorical columns from the dataframe.
plot
-
bool, Default False.
Plots the class counts as a barplot
save_fig
-
bool, Default False.
Saves the plot to the current working directory.
Expand source code
def class_count(data=None, features=None, plot=False, save_fig=False): ''' Displays the number of classes in a categorical feature. Parameters: data: Pandas DataFrame or Series Dataset for plotting. features: Scalar, array, or list. The categorical features in the dataset, if None, we try to infer the categorical columns from the dataframe. plot: bool, Default False. Plots the class counts as a barplot save_fig: bool, Default False. Saves the plot to the current working directory. ''' if data is None: raise ValueError("data: Expecting a DataFrame or Series, got 'None'") if features is None: features = structdata.get_cat_feats(data) for feature in features: if data[feature].nunique() > 15: print("Unique classes in {} too large".format(feature)) else: print('Class Count for', feature) display(pd.DataFrame(data[feature].value_counts())) if plot: countplot(data, features, save_fig=save_fig)
def countplot(data=None, features=None, separate_by=None, fig_size=(5, 5), save_fig=False)
-
Makes a bar plot of all categorical features to show their counts.
Parameters
data : DataFrame, array, or list of arrays. The data to plot. features: str, scalar, array, or list. The categorical features in the dataset, if not provided, we try to infer the categorical columns from the dataframe. separate_by: str, default None. The feature used to seperate the plot. Called hue in seaborn. fig_size: tuple, Default (5,5) The size of the figure object. save_fig: bool, Default False. Saves the plot to the current working directory
Returns
None
Expand source code
def countplot(data=None, features=None, separate_by=None, fig_size=(5,5), save_fig=False): ''' Makes a bar plot of all categorical features to show their counts. Parameters ------------ data : DataFrame, array, or list of arrays. The data to plot. features: str, scalar, array, or list. The categorical features in the dataset, if not provided, we try to infer the categorical columns from the dataframe. separate_by: str, default None. The feature used to seperate the plot. Called hue in seaborn. fig_size: tuple, Default (5,5) The size of the figure object. save_fig: bool, Default False. Saves the plot to the current working directory Returns ------- None ''' if data is None: raise ValueError("data: Expecting a DataFrame or Series, got 'None'") if features is None: features = structdata.get_cat_feats(data) for feature in features: #Check the size of categories in the feature: Anything greater than 20 is not plotted if len(data[feature].unique()) > 30: print("Unique Values in {} is too large to plot".format(feature)) print('\n') else: fig = plt.figure(figsize=fig_size) ax = fig.gca() sns.countplot(x=feature, hue=separate_by, data=data) plt.xticks(rotation=90) ax.set_title("Count plot for " + feature) if save_fig: plt.savefig('Countplot_{}'.format(feature))
def histogram(data=None, num_features=None, bins=None, show_dist_type=False, fig_size=(5, 5), save_fig=False)
-
Makes an histogram plot of all numerical features. Helps to show univariate distribution of the features.
Parameters
data : DataFrame, array, or list of arrays. Dataset for plotting. num_features: Scalar, array, or list. The numerical features in the dataset, if not None, we try to infer the numerical columns from the dataframe. bins: int The number of bins to use. show_dist_type: bool, Default False If True, Calculates the skewness of the data and display one of (Left skewed, right skewed or normal) fig_size: tuple, Default (8,8). The size of the figure object. save_fig: bool, Default False. If True, saves the current plot to the current working directory
Expand source code
def histogram(data=None, num_features=None, bins=None, show_dist_type=False, fig_size=(5,5), save_fig=False): ''' Makes an histogram plot of all numerical features. Helps to show univariate distribution of the features. Parameters ------------ data : DataFrame, array, or list of arrays. Dataset for plotting. num_features: Scalar, array, or list. The numerical features in the dataset, if not None, we try to infer the numerical columns from the dataframe. bins: int The number of bins to use. show_dist_type: bool, Default False If True, Calculates the skewness of the data and display one of (Left skewed, right skewed or normal) fig_size: tuple, Default (8,8). The size of the figure object. save_fig: bool, Default False. If True, saves the current plot to the current working directory ''' if data is None: raise ValueError("data: Expecting a DataFrame or Series, got 'None'") if num_features is None: num_features = structdata.get_num_feats(data) for feature in num_features: fig = plt.figure(figsize=fig_size) ax = fig.gca() sns.distplot(data[feature].values, ax=ax, bins=bins) ax.set_xlabel(feature) # Set text for the x axis ax.set_ylabel('Count')# Set text for y axis if show_dist_type: ##TODO Add Code to calculate skewness pass else: ax.set_title('Histogram of ' + feature) if save_fig: #TODO Add function to save to a user specified directory plt.savefig('fig_hist_{}'.format(feature)) plt.show()
def plot_auc(labels, predictions)
-
Computes and plot the false positive rate, true positive rate and threshold along with the AUC Parameters:
labels: This is the true value ( in the case of binary either 0 or 1)
predictions:
This is the probability that shows the likelihood of a value being 0 or 1
Return
plots the Receiver operating characteristics.
Expand source code
def plot_auc(labels, predictions): ''' Computes and plot the false positive rate, true positive rate and threshold along with the AUC Parameters: -------------------- labels: This is the true value ( in the case of binary either 0 or 1) predictions: This is the probability that shows the likelihood of a value being 0 or 1 Return: plots the Receiver operating characteristics. ''' fpr, tpr, threshold = sklm.roc_curve(labels, predictions) auc = sklm.auc(fpr, tpr) ## Plot the result plt.title('Receiver Operating Characteristic') plt.plot(fpr, tpr, color='orange', label='AUC = %0.2f' % auc) plt.legend(loc='lower right') plt.plot([0, 1], [0, 1], 'r--') plt.xlim([0, 1]) plt.ylim([0, 1]) plt.ylabel('True Positive Rate') plt.xlabel('False Positive Rate') plt.show()
def plot_confusion_matrix(y_true, y_pred, classes, normalize=False, title=None, cmap=<matplotlib.colors.LinearSegmentedColormap object>)
-
This function prints and plots the confusion matrix. Normalization can be applied by setting
normalize=True
.Parameters:
Expand source code
def plot_confusion_matrix(y_true, y_pred, classes, normalize=False, title=None, cmap=plt.cm.Blues): """ This function prints and plots the confusion matrix. Normalization can be applied by setting `normalize=True`. Parameters: """ if not title: if normalize: title = 'Normalized confusion matrix' else: title = 'Confusion matrix, without normalization' # Compute confusion matrix cm = confusion_matrix(y_true, y_pred) # Only use the labels that appear in the data classes = classes[unique_labels(y_true, y_pred)] if normalize: cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis] print("Normalized confusion matrix") else: print('Confusion matrix, without normalization') print(cm) fig, ax = plt.subplots() im = ax.imshow(cm, interpolation='nearest', cmap=cmap) ax.figure.colorbar(im, ax=ax) # We want to show all ticks... ax.set(xticks=np.arange(cm.shape[1]), yticks=np.arange(cm.shape[0]), # ... and label them with the respective list entries xticklabels=classes, yticklabels=classes, title=title, ylabel='True label', xlabel='Predicted label') # Rotate the tick labels and set their alignment. plt.setp(ax.get_xticklabels(), rotation=45, ha="right", rotation_mode="anchor") # Loop over data dimensions and create text annotations. fmt = '.2f' if normalize else 'd' thresh = cm.max() / 2. for i in range(cm.shape[0]): for j in range(cm.shape[1]): ax.text(j, i, format(cm[i, j], fmt), ha="center", va="center", color="white" if cm[i, j] > thresh else "black") fig.tight_layout() return ax
def plot_missing(data=None)
-
Plots the data as a heatmap to show missing values
Parameters
data: DataFrame, array, or list of arrays. The data to plot.
Expand source code
def plot_missing(data=None): ''' Plots the data as a heatmap to show missing values Parameters ---------- data: DataFrame, array, or list of arrays. The data to plot. ''' if data is None: raise ValueError("data: Expecting a DataFrame or Series, got 'None'") sns.heatmap(data.isnull(), cbar=True) plt.show()
def plot_scatter_shape(data=None, cols=None, shape_col='', col_y='', alpha=0.2)
-
Makes a scatter plot of data using shape_col as seperation.
Parameter
data
- Dataframe The data that is being imported using pandas.
cols
- list The chosen number of columns in the DataFrame.
shape_col
- The categorical column you want it to show as legend.
col_y
- The y axis of the plot
Return
Matplotlib figure
Expand source code
def plot_scatter_shape(data = None, cols = None, shape_col = '', col_y = '', alpha = 0.2): ''' Makes a scatter plot of data using shape_col as seperation. Parameter: data: Dataframe The data that is being imported using pandas. cols: list The chosen number of columns in the DataFrame. shape_col: The categorical column you want it to show as legend. col_y: The y axis of the plot Return: Matplotlib figure ''' # pick distinctive shapes shapes = ['+', 'o', 's', 'x', '^'] unique_cats = data[shape_col].unique() # loop over the columns to plot for col in cols: sns.set_style("whitegrid") # loop over the unique categories for i, cat in enumerate(unique_cats): temp = data[data[shape_col] == cat] sns.regplot(col, col_y, data=temp, marker = shapes[i], label = cat, scatter_kws={"alpha":alpha}, fit_reg = False, color = 'blue') # Give the plot a main title plt.title('Scatter plot of ' + col_y + ' vs. ' + col) # Set text for the x axis plt.xlabel(col) # Set text for y axis plt.ylabel(col_y) plt.legend() plt.show()
def scatterplot(data=None, num_features=None, target=None, separate_by=None, fig_size=(5, 5), save_fig=False)
-
Makes a scatter plot of numerical features against a numerical target. Helps to show the relationship between features.
Parameters
data : DataFrame, array, or list of arrays. The data to plot. num_features: int/floats, scalar, array, or list. The numeric features in the dataset, if not provided, we try to infer the numeric columns from the dataframe. target: int/float, scalar, array or list. Numerical target feature to plot against. separate_by: str, default None. The feature used to seperate the plot. Called hue in seaborn. fig_size: tuple, Default (10,10) The size of the figure object. save_fig: bool, Default False. Saves the plot to the current working directory
Expand source code
def scatterplot(data=None, num_features=None, target=None, separate_by=None, fig_size=(5,5), save_fig=False): ''' Makes a scatter plot of numerical features against a numerical target. Helps to show the relationship between features. Parameters ------------ data : DataFrame, array, or list of arrays. The data to plot. num_features: int/floats, scalar, array, or list. The numeric features in the dataset, if not provided, we try to infer the numeric columns from the dataframe. target: int/float, scalar, array or list. Numerical target feature to plot against. separate_by: str, default None. The feature used to seperate the plot. Called hue in seaborn. fig_size: tuple, Default (10,10) The size of the figure object. save_fig: bool, Default False. Saves the plot to the current working directory ''' if data is None: raise ValueError("data: Expecting a DataFrame or Series, got 'None'") if separate_by is None: pass elif separate_by not in data.columns: raise ValueError("{} not found in data columns".format(separate_by)) if target is None: raise ValueError('Target value cannot be None') if num_features is None: num_features = structdata.get_num_feats(data) for feature in num_features: fig = plt.figure(figsize=fig_size) # define plot area ax = fig.gca() # define axis sns.scatterplot(x=feature, y=target, data=data, hue=separate_by) ax.set_title("Scatter Plot of '{}' vs. '{}' \n Separated by: '{}'".format(feature, target, separate_by)) if save_fig: plt.savefig('fig_scatterplot_{}'.format(feature))
def violinplot(data=None, num_features=None, target=None, fig_size=(5, 5), save_fig=False)
-
Makes a violin plot of all numerical features against a specified categorical target column.
A violin plot plays a similar role as a box and whisker plot. It shows the distribution of quantitative data across several levels of one (or more) categorical variables such that those distributions can be compared. Unlike a box plot, in which all of the plot components correspond to actual datapoints, the violin plot features a kernel density estimation of the underlying distribution. Parameters
data : DataFrame, array, or list of arrays. Dataset for plotting. num_features: Scalar, array, or list. The numerical features in the dataset, if not None, we try to infer the numerical columns from the dataframe. target: array, pandas series, list. A categorical target column. Maximun number of categories is 10 and minimum is 1. fig_size: tuple, Default (8,8) The size of the figure object. save_fig: bool, Default False. If True, saves the current plot to the current working directory
Expand source code
def violinplot(data=None, num_features=None, target=None, fig_size=(5,5), save_fig=False): ''' Makes a violin plot of all numerical features against a specified categorical target column. A violin plot plays a similar role as a box and whisker plot. It shows the distribution of quantitative data across several levels of one (or more) categorical variables such that those distributions can be compared. Unlike a box plot, in which all of the plot components correspond to actual datapoints, the violin plot features a kernel density estimation of the underlying distribution. Parameters ------------ data : DataFrame, array, or list of arrays. Dataset for plotting. num_features: Scalar, array, or list. The numerical features in the dataset, if not None, we try to infer the numerical columns from the dataframe. target: array, pandas series, list. A categorical target column. Maximun number of categories is 10 and minimum is 1. fig_size: tuple, Default (8,8) The size of the figure object. save_fig: bool, Default False. If True, saves the current plot to the current working directory ''' if target is None: raise ValueError('Target value cannot be None') if len(data[target].unique()) > 10: raise AttributeError("Target categories must be less than 10") if data is None: raise ValueError("data: Expecting a DataFrame or Series, got 'None'") if num_features is None: num_features = structdata.get_num_feats(data) for feature in num_features: fig = plt.figure(figsize=fig_size) ax = fig.gca() sns.set_style("whitegrid") sns.violinplot(target, feature, data=data, ax=ax) plt.xticks(rotation=90) plt.ylabel(feature) # Set text for the x axis plt.xlabel(target)# Set text for y axis plt.title("Violin plot of '{}' vs. '{}'".format(feature, target)) if save_fig: #TODO Add function to save to a specified directory plt.savefig('fig_{}_vs_{}'.format(feature,target)) plt.show()


As an advisor, you have always chosen to serve the students above all else.
"I would rather see this school shut down before I sell out my own students."
You quickly leave the building and get into your car.
You pull out your cellphone and call the anonymous tip line for the local newspaper.
The next morning you wake up and turn on your TV to the local news.
In a bold box below the reporter were the words "School Sells Out Students"
You quickly raise the volume.
"... had required students to download an app to monitor their performance.
What they didn't know was that the app was also listening into their conversations, reading their personal emails and much more.
We have also just found out that they were selling this data to other companies to build user profiles.
According to the company plans, they were using this school as a trial program and if successful, were planning on migrating it to other schools.
Fortunately through an anonymous tip we received, we were able to bring these plans to light ..."


Preparation time
30 mins to 1 hour
Cooking time
10 to 30 mins
Serves
Serves 4
This classic way with leftover Christmas turkey is a crunchy, tangy treat perfect for a Saturday night fakeaway.
For the turkey, in a bowl, mix together the sherry, soy sauce, sesame oil and salt until well combined. Add the cooked turkey to the marinade, stir well to coat, then cover the bowl and set aside to marinate for at least 20 minutes.
Heat the deep-fat fryer to 180C. Alternatively, heat the oil in a deep-sided, heavy-based saucepan until a breadcrumb sizzles and turns golden-brown when dropped into it (CAUTION: hot oil can be dangerous. Do not leave unattended.).
Meanwhile, in a bowl, beat the egg with the cornflour to form a smooth batter and set aside. Sprinkle a little cornflour on a plate.
Remove the turkey from its marinade, shaking off any excess. Dust the marinated turkey with the cornflour, shaking off any excess.
Dip the marinated turkey in the batter, then carefully lower into the hot oil, in batches if necessary, and fry for 2-3 minutes, or until the batter is crisp and golden-brown. Remove the turkey from the oil using and set aside to drain on kitchen paper. Keep warm.
For the sauce, bring the stock, soy sauce, sesame oil, vinegar and ketchup to the boil in a non-reactive saucepan. Add the peppers and spring onions and simmer for 2-3 minutes, or until the vegetables have softened slightly but still retain their crunch.
Mix the satsuma juice with the cornflour to form a smooth paste. Pour into the sauce and bring to the boil. Then reduce and simmer for 1-2 minutes, stirring well, until the sauce has thickened.
Meanwhile, for the egg fried rice, heat the oil in a wok over a high heat. Add the rice and stir-fry for 2-3 minutes. Add the egg, spring onions and soy sauce and stir-fry for a further 2-3 minutes.
Just before serving, stir the turkey into the sweet-and-sour sauce.
To serve, spoon the egg-fried rice into serving bowls and top with the sweet-and-sour turkey.


Functions for interacting with the Adobe Analytics API V1.4 (<https://api.omniture.com/admin/1.4/rest/>).
| Version: | 1.4.15 |
| Depends: | R (≥ 3.0) |
| Imports: | jsonlite (≥ 0.9.5), httr (≥ 0.3), plyr, base64enc, digest, stringr |
| Suggests: | testthat |
| Published: | 2018-04-22 |
| Author: | Willem Paling, Randy Zwitch & Jowanza Joseph |
| Maintainer: | Randy Zwitch <rzwitch+rsitecatalyst at gmail.com> |
| BugReports: | https://github.com/randyzwitch/RSiteCatalyst |
| License: | MIT + file LICENSE |
| NeedsCompilation: | no |
| Materials: | NEWS |
| In views: | WebTechnologies |
| CRAN checks: | RSiteCatalyst results |
| Reference manual: | RSiteCatalyst.pdf |
| Package source: | RSiteCatalyst_1.4.15.tar.gz |
| Windows binaries: | r-devel: RSiteCatalyst_1.4.15.zip, r-release: RSiteCatalyst_1.4.15.zip, r-oldrel: RSiteCatalyst_1.4.15.zip |
| OS X binaries: | r-release: RSiteCatalyst_1.4.15.tgz, r-oldrel: RSiteCatalyst_1.4.15.tgz |
| Old sources: | RSiteCatalyst archive |
Please use the canonical form https://CRAN.R-project.org/package=RSiteCatalyst to link to this page.


Overview
This addon is used to communicate with
an ECU over a diagnostic protocol. Supported protocols are
KWP, UDS, & GMLAN. CAN is the supported physical layer. The
supported services for each protocol are listed below. Note: This addon
requires a valid license for the NI Automotive Diagnostic Command Set
(ADCS) 19.0+.
Repo
Location:
NIVeriStandAdd-Ons/Diagnostics-Custom-Device · GitHub
Requirements
These drivers must be installed on the
deployment computer/target to function.
Addon
Specifics
Supported Services
The addon reads DIDs, PIDs (GMLAN
only), memory (KWP/UDS only) and DTCs. It writes DIDs, CPIDs
(GMLAN only), memory (KWP/UDS only) and clears DTCs. In GMLAN, PIDs
are dynamic data (values change from read to read, ie
sensor data). DIDs are static data (values don't change from
read to read, ie VIN number). In UDS and KWP2000,
DIDs are dynamic and static data. DTCs are diagnostic trouble codes. CPIDs
are output PIDs. KWP/UDS also supports IO control and routines
(start, stop, status). Custom (user defiend) messages
are supported by all protocols. More specifically, the services
currently implemented are:
UDS
KWP
GMLAN Only
Addon Configuration
Upon adding the addon, an configuration GUI
will open. Select the desired diagnostic protocol and base baud rate.
Optionally, a previously exported diagnostics addon configuration can be
imported.
The addon will be added to the system
definition. There will sections added for all the supported services.
On the main page, you can change the CAN
port, CAN mode (CAN 2.0, CAN FD, CAN FD + BRS), Baud Rate, and
Termination. The search button (magnifier glass icon) will detect the available
CAN ports on the current Target/Controller.
Also, notice the built in help. This help
provides the details needed to use each service.
Go to the Protocol Settings tab
and set the Transmit ID (master to ECU) and Receive ID (ECU to
master). Diagnostic protocols are command/response based. These IDs are the
specific frame command and response IDs used for the communication. They
are company and ECU specific. GMLAN has a third ID for
push-based messages (breaks the normal command/response paradigm).
After these settings are entered, an initial
test of the configuration is recommend. Deploy the system
definition, check that the Tester Present service is working without
errors, and confirm the expected Transmit and Recieve
IDs are on the bus (using NI XNET Bus Monitor or the included
tool's bus stream discussed below). If
this test is not successful, make sure the ECU is powered and
wired, confirm basic CAN is working, check for bus
errors, confirm the CAN and protocol settings with the ECU experts,
check for negative diagnostic responses, etc. If the test is successful,
continue setting up the addon.
Each service has the same basic structure.
There are Services Channels that control and report on the service.
Trigger, for example, will force the service
to execute or update. Timestamp reports when it last executed. Success and
Error Code report the service status.
Additionally, some service have Settings,
Command, or Response sections.
Settings generally control or parameterize the
service. Command and Response sections contain the data within the service
frame.
Some services work without any additional
configuration. Tester Present, for example. Other services, like reading DIDs,
need more information. In most cases, there will be an Add, Import and/or
Edit button.
When adding, a service specific pop up will
appear. As an example, when configuring memory, DIDs,
or PIDs, the GUI is as follows:
Add signals using the Add button.
Configure them and hit the check
button. When completed, hit Apply.
A DPID is a collection of PIDs. This is a
GMLAN specific item. A typical DPID configuration is as follows:
Again, hit the add button to
select a PID.
Select the PID from the drop down box and hit
the check button. Repeat until all desired PIDs are selected. Hit Apply.
Other service like IO Control and Routines
define the identifiers.
Then go edit the specific Settings,
Commands, and Responses.
As for importing, a basic .CSV file can be
used to quickly add many items. The specific
import formats are defined per service in:
C:\Users\Public\Documents\National
Instruments\NI VeriStand <year>\Custom Devices\Diagnostics
Addon\Windows\Import File Formats
Some of the services have special
configurations on the section itself. Unlock ECU and Read DTCs are two example.
For Unlock ECU, select None (ECU already unlocked), DLL (or shared object
depending on the target's operating system) or use a Master Key.
In the case of Read DTCs (Start
DTCs in GMLAN), set the byte length and formating of
the DTCs as well as the maximum number of expected DTCs.
Additionally, import a set of numeric to
string values for the DTC codes and status.
As with above, the file format examples for
this are located at:
C:\Users\Public\Documents\National
Instruments\NI VeriStand <Year>\Custom Devices\Diagnostics
Addon\Windows\Import File Formats
Polling of particular services is supported by
the addon. Polls are an application feature of the addon, not a
diagnostic service. The normal operation of diagnostics is event
based. However, users often want to periodically monitor a
particular DID, PID, or memory location. Polls were added to make this
simpler. Add a poll, select the desired items to monitor,
and select the rate.
Similar to all other services,
"Enable" the poll in Settings and "Trigger" to apply.
Similar to polls, there is an application
feature (not a service) to do mass functions through the Command channel.
As an example, if there are multiple DID inputs, normally
the "Trigger" channel must be set to 1 per each DID to
read the latest value. The Command channel can be set to "2"
or "Read All DIDs" to do a mass reading.
Once everything is configured, export the
configuration. This makes it so the services are defined once and can then
be easily re-used in any other configurations.
Addon Execution
Deploy the system definition. From within the
user interface, drag and drop services as sections.
Change required channels to controls,
such as Trigger and anything in Settings.
Certain channels can be added as Rings to show
text. The command channel supports this.
So do error code channels.
And so do DTC Value and DTC Status channels,
if they have been setup on the Read/Start DTCs section in the system
definition.
Addon Tool
The diagnostics addon also comes with a
host tool that provides additional features. These features help in manual
testing and debugging. You can add this tool to the project files:
It can also be added as a button to the
UI screen.
Click open on the file or select the
configured button to launch the tool.
Select File >> Configure and
select the desired addon.
From there, send addon commands.
Send raw commands.  Therefore, they can be over 8 bytes.
View diagnostic trouble codes.
Monitor the raw bus stream. From here,
filter the bus messages and log traffic.
Host Automation API
In addition to the above items, there is an
automation API that can be used from Windows to initiate commands with the
add-on. This is installed at:
C:\Users\Public\Documents\National
Instruments\NI VeriStand <Year>\Custom Devices\Diagnostics
Addon\Windows\Host Automation API
An example of using this API is as follows:
Notice that the read DTCs function
returns an array of variable size. This is a feature which VeriStand
can't inherently support.
System Definition API
There is also a system definition API that
allows the user to programatically create an instance
of the addon from a previously exported configuration. This is
installed at:
C:\Users\Public\Documents\National
Instruments\NI VeriStand <Year>\Custom Devices\Diagnostics
Addon\Windows\System Definition API
An example of using this API is as follows:


{{define "main"}} {{- partial "donate_banner.html" . -}} Heidi is going sober for October {{.Params.heidi_text | markdownify }} Her friend Jonathan... isn't {{.Params.jonathan_text | markdownify }}


try to be
professional in
JS
as soon as
I can
emphassize visual is the same as Italic
strong visual is the same as bold
Today, 8 th, we want to reduce CO2 emission in the world
we are bro
we are pro
i am IT student in NMIT,living in Nelson
<EMAIL_ADDRESS>NMIT
Nelson7010
click here to open


:(
Your PC ran into a problem and needs to restart. We're just
collecting some error info, and then we'll restart for you.
There is pretty much nothing you can do,
as the app doesn't exist, or you crashed in on purpose.
Here's the error code anyways:
Stop Code: KERNEL_ERROR_NOT_HANDELED


Visualizes two-dimensional geoelectric resistivity measurement profiles in three dimensions.
| Version: | 0.2.0 |
| Depends: | R (≥ 3.0), lattice, rgl, fields |
| Imports: | methods |
| Suggests: | covr, testthat |
| Published: | 2018-08-28 |
| Author: | Anja Kleebaum |
| Maintainer: | Anja Kleebaum <kleebaum at informatik.uni-heidelberg.de> |
| BugReports: | https://github.com/kleebaum/geoelectrics/issues |
| License: | GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| URL: | https://github.com/kleebaum/geoelectrics |
| NeedsCompilation: | no |
| Language: | en-US |
| CRAN checks: | geoelectrics results |
| Reference manual: | geoelectrics.pdf |
| Package source: | geoelectrics_0.2.0.tar.gz |
| Windows binaries: | r-devel: geoelectrics_0.2.0.zip, r-release: geoelectrics_0.2.0.zip, r-oldrel: geoelectrics_0.2.0.zip |
| OS X binaries: | r-release: geoelectrics_0.2.0.tgz, r-oldrel: geoelectrics_0.2.0.tgz |
| Old sources: | geoelectrics archive |
Please use the canonical form https://CRAN.R-project.org/package=geoelectrics to link to this page.


Gundam Uc Ep4 Theme Song B Bird By Earthmind Cd Review No 12 Large Images Download Mp3 Gunjap
Gundam Uc Ep4 Theme Song B Bird By Earthmind Cd Review No 12 Large Images Download Mp3 Gunjap
Gundam Uc Ep4 Theme Song B Bird By Earthmind Cd Review No 12 Large Images Download Mp3 Gunjap
Gundam Uc Ep4 Theme Song B Bird By Earthmind Cd Review No 12 Large Images Download Mp3 Gunjap
Gundam Uc Ep4 Theme Song B Bird By Earthmind Cd Review No 12 Large Images Download Mp3 Gunjap
B Bird Archives Music Comedy Entertainment News World News Videos Downloads Radio Station Music Upload
Quail Hunting Voice Hunting Birds Sounds For Download Hunting Bird Sound Mp3 Speaker From Bj Outdoor Buy Quail Hunting Voice Hunting Birds Sounds For Download Hunting Bird Sound Mp3 Product On Alibaba Com
Daytoner Mr Bird Ft The Audible One Daisy B Earthly Crowd Daytoner
Grasscut Everyone Was A Bird Mp3 Bleep
Angry Birds 10th Anniversary Music Collection Birds Vs Pigs Forever Mp3 Download Angry Birds 10th Anniversary Music Collection Birds Vs Pigs Forever Soundtracks For Free


2 Chronicles 24:10
And all the princes and all the people rejoiced, and brought in, and cast into the chest, until they had made an end.


A Programmer's Nightmare
One day, at am sharp, , the best programmer in the world, logged onto to google meets to start morning standup. To surprise, there was a doing . The best programmer in the world was shocked and decided to quickly . Unfortunately this did nothing to help this situation, it only made things worse. The End.


The DjangoCon website was built using several Open Source technologies. Below is a list of the most important packages, with their respective documentation.


Invoices
Home
Invoices
Overview
Overview
Add
Message
Message
ID
Customer
Date created
Date payed
State
Vat
Payment Condition
Mark as paid
Update state
%
Change payment condition


| RGBFIX(1) | General Reference Manual | RGBFIX(1) |
| rgbfix | [-Ccjsv] [-i game_id] [-k licensee_str] [-l licensee_id] [-m mbc_type] [-n rom_version] [-p pad_value] [-r ram_size] [-t title_str] file |
The following will make a plain, no-color Game Boy game without checking for a valid size:
$ rgbfix -v foo.gb
The following will make a SGB-enabled, color-enabled game with a title of “foobar”, and pad it to a multiple of 32KiB. (The Game Boy itself does not use the title, but some emulators or ROM managers might.)
$ rgbfix -vcs -l 0x33 -p 0 -t foobar baz.gb
The following will duplicate the header (sans global checksum) of the game “Survival Kids”:
$ rgbfix -cjsv -k A4 -l 0x33 -m 0x1B -p 0xFF -r 3 -t SURVIVALKIDAVKE SurvivalKids.gbc
| April 11, 2013 | RGBDS Manual |


Since 2014 we organize Fellowships at municipalities. You can register now for 2018!
One or more will run during a Code for NL fellowship professional designers and developers join a (semi-) government, to implement or make open source ICT solutions for social issues.
Such as: How can citizens gain insight into relevant information from their government? How do we organize participation at local level? How do we support people with a limitation in the use of public space?
Are you a designer or developer and would you like to have a half? year in a municipality or other government? Or am you are looking for ICT professionals on behalf of a municipality provide suitable digital solutions?
Sign up! Send an email to<EMAIL_ADDRESS>stating your name, contactdetails and a short motivation. We will contact you as soon as possible.


| Title | Description | Category | Priority Level | Progress Level |
|---|---|---|---|---|
| Reading | Read module 2 of ICT 694 | Self Study | High | Completed |
| Reading | Read module 3 of ICT 694 | Self Study | High | Pending |
| Reading | Read module 4 of ICT 694 | Self Study | High | Pending |
| Reading | Read module 5 of ICT 694 | Self Study | High | Pending |


Deliver JET via CDN
While playing with some IoT devices such as the JavaScript-centric JohnnyFive Tessel 2 board, I wanted to deploy some JET code onto the microcontroller to be delivered by the board’s Express Node.js server.
In the Tessel tutorial there is sample code that uses the JustGage library to show sensor data streaming via Socket.io. The deployment steps in that tutorial describe how to ship the supporting node_modules over to the Tessel 2 board, but the more you add to your project the heavier the deployment becomes and the longer it takes to copy over.
Shipping all of the JET supporting modules and all of their dependencies is a whole lot heavier than only one library like JustGage. Even if you take steps to whittle down the included JET module bundles or minimize the code that gets copied to web/js/libs/
, it’s still a boatload of code to deploy to the Tessel – especially since it will all simply be served right back to a client and isn’t really needed to be resident on the board.
Using a CDN instead
The client machine running the JET code doesn’t really care where the Require.js, Knockout, oj, and other supporting code comes from, as long as it gets there fast. Instead of serving these dependency libraries off of a low-power IoT board like the Tessel, we can rewrite our JET configs and use a content delivery network to serve up all the libraries when our client accesses the app we deploy to our Express server.
Starting with v4.0.0, Oracle JET is available via a CDN and doesn’t have to be running from the same server that delivers your html and js files.
The instructions in that documentation link are straightforward: You change the path mappings for Require.js in main.js
and main-release-paths.json
and also point to the hosted Alta stylesheet and Require.js bootstrap in index.html
. In that same file I also had to remove the <!-- injector:theme -->
comment pair because the build scripts would otherwise try to keep reinserting the local reference to the standard theme’s stylesheet instead of respecting the CDN-hosted Alta stylesheet.
Deploying to a microcontroller’s node.js
With the CDN-only version of my JET code, I was able to deploy the built index.html
, main.js
and appcontroller.js
files from a ojet create --template=basic
project to be delivered by the Express server running on my Tessel’s node.js. Per the instructions in the J5IK tutorial, I slipped the assets in an app
folder and mapped it as a static Express route. But thanks to the CDN there was no need to add the JET dependencies from the node_modules
folder into the .tesselinclude
file.
This way I “upgraded” the gauges to JET and was able to use websockets to stream the Tessel’s BME280 environmental sensors’ data to the JET visualizations. The modified code up on GitHub also shows how to hook Socket.io into the Require.js framework for JET.
Using the CDN for JSFiddles and CodePens
We had to use a similar idea in the past to deploy sample JET code to services such as JSFiddle and CodePen (which don’t have an option to dynamically load JET). Back then we set up links to raw GitHub files as a poor-man’s CDN, but with the official approach available now I’ve rewritten the CodePen and JSFiddle templates and you can fork these to prototype JET ideas or troubleshoot implementation issues.


Default sorting Sort by average rating Sort by newness Sort by price: low to high Sort by price: high to low


ok, how about this:
on the first and second notarizations for a chain, make a DB entry symbol.first <- notarization, symbol.second <- notarization
if both those exist, then 2+ have been done
and on new notarization if first and second are not there, make first. if first is there but second isnt, make second
1


RASC Robots
Robotics and Autonomous Systems Center
Home
About
Research
Robots
People
Events
News
Education
Outreach
RASC News
This is the new News page! Check back later for more updates.
Maja Mataric named Distinguished Professor
Viterbi's Robotics and Coding Academy
Robotic Leg Learns to Walk (Brain-Body Dynamics Lab)
Haptic Armband to Mimic Human Touch (HaRVI Lab)
Bio-Inspired Robot Course
Robot Patrols City Pipes


fromJson<T> method
Invoked for core types and for unknown ones having no explicit write method specified.
Implementation
static T fromJson<T>(String json, {T seed}) {
if (T == String) return json as T;
if (seed is JsonModel) {
return seed.fromJson(jsonDecode(json)) as T;
} else {
dynamic decoded = jsonDecode(json);
if (decoded is int && T == double) {
return decoded.toDouble() as T;
}
if (decoded is double && T == int) {
return decoded.toInt() as T;
}
return jsonDecode(json) as T;
}
}


Limitless - Themes
Default theme
Starting from version 1.3, template themes are located in different folders. Default theme is located now in /default/
folder. Files structure remains the same.
Screenshot - default theme
Material theme
Material theme has been added in version 1.3. It does have a lot of differences with default theme:
- HTML files - some of HTML files are different, mainly because some of features from default theme aren't supported
- LESS files - here everything differs: all files are different from default theme - variables, components. Colors and default bootstrap theme are the same in all themes
- JS files - mainly are the same as in default theme, but some of them have minor changes in integrated themes
Screenshot - material theme
Switching between themes
Since components and core features are identical in all themes, you can easily switch between themes - you just need to replace CSS files in your current theme with those from a theme you want to use. Also, depending on component or feature, you can also review JS files with example configurations located in global_assets/js/demo_pages/
folder - some pages contains a bit different configurations to match theme specifications: file uploaders, selects classes, colors etc. Nothing too important.
Screenshot - replace CSS files


|
Dear Yasemin Thank you for the opportunity to quote on your stay at The Trans Resort is The Best Hotels in Seminyak - Bali. At this stage we have availability for your requested dates in one of our Premier Room. Room rate inclusive of:
To secure a booking request we require a deposit equivalent to one night's stay. This can be made via our Secure Online Payment form by clicking on the Request Booking button below or you may prefer to telephone direct +62<PHONE_NUMBER> with your payment details on We will then process and confirm your booking. Relax and enjoy one of the most beautiful places in the world....Bali, the famed Island of the Gods. Regards, |
|
QUOTATION No. : #575330-620460 |
|
|
||
| Client Details | ||
| Enquiry Type | : Group Enquiry | |
| Date | : 01 May 2017 - 15 May 2017 | |
| # of nights | : 14 | |
| Quantity | : 0 - ( type : Premier Room ) | |
| # of Persons | : 10 Adult, 8 Children, 0 Infant | |
| Name | : Yasemin | |
| Address | , , Melbourne, Victoria, Australia, Ph. Mobile<EMAIL_ADDRESS>|
|
|
| Accommodation Options |
|
The Trans Resort is The Best Hotels in Seminyak - Bali has been described as a palace of refined luxury and privileged hospitality having welcomed Kings, Queens, Presidents and other dignitaries over the years. Located 25-minute away from Bali's International Airport, the tranquility of the Bali resort spreads over 23 acres with an oasis of tropical gardens and sun-drenched shores. Immerse yourself in this five-star diamond hotel with its vibrant Balinese culture. Please don't hesitate to contact us if you have any further questions or would like some more information about the The Trans Resort is The Best Hotels in Seminyak - Bali. |
|
Insert quotation details here |