CBSE syllabus for class 11 Physics, Chemistry, Mathematics, Biology, Accountancy, Business Studies, History, Geography and other subjects.
Class 11 is a future deciding part of the academic career and with the lengthy syllabus sometimes students get confused. We keep researching on this issue to solve this pain point by reducing the curriculum load by eliminating overlapping of concept and content. For your convenience, each subject is individually dealt with new CBSE curriculum and rectified accordingly.


| Time | Title | Speaker | Room |
|---|---|---|---|
| 10-11am | A Session Title | Alec Guiness | Room 1 |
| 10-11am | Another Session Title | Mark Hamill | Room 2 |
| 11am-12pm | The Session Before Lunch | Carrie Fisher | Room 1 |
| 11am-12pm | the other session before lunch | Anthony Daniels | Room 2 |
| 12-1pm | Lunch | Main Hall | |
| 1-2pm | The Session After Lunch | Harrison Ford | Room 1 |
| 1-2pm | The Session After Lunch | Kenny Baker | Room 2 |


Red Bull-Honda straightline speed in Brazil surprises F1 rivals
by Scott MitchellMax Verstappen's Formula 1 rivals Lewis Hamilton and Sebastian Vettel say they are surprised by Red Bull's straightline speed performance in Brazilian Grand Prix qualifying.
Verstappen will start Sunday's race at Interlagos from pole position after dominating qualifying in his Honda-powered Red Bull, which Ferrari driver Vettel claimed was not losing any time on the straights.
Red Bull has been underpowered throughout F1's V6 turbo-hybrid engine era and its new-for-2019 partner Honda has been playing catch up since it joined the grid in 2015.
However, after being defeated by Verstappen's latest strong qualifying performance, Vettel said: "We have to admit that we were beaten fair and square today.
"It was a bit of a surprise. Not to see them quick, but to see them that quick on the straights."
Vettel's own team has been under scrutiny in recent weeks for its engine performance advantage, particularly in qualifying.
Verstappen even alleged after the United States Grand Prix that the absence of Ferrari's usual top-speed edge was a direct result of an FIA technical directive that stated ways to exploit fuel-flow rules would be illegal.
Another technical directive was issued ahead of this weekend's race, reminding teams of previous instructions outlawing burning oil for performance gains and asking teams to submit lubricant information to help ensure nobody is breaking the rules.
Reiterating his surprise at Red Bull's performance, Vettel said Ferrari is in the same spec as previous races and he does not know why the competitive picture is different in Brazil.
"We've seen a lot of qualifying sessions when we were always a bit faster than everyone on the straights and losing a bit in the corners," said Vettel.
"But today we were as quick, or Max and Alex were as fast, on the straights.
"That's about it. I don't know why. We didn't do anything different."
Hamilton, who wrapped up his sixth F1 title at the previous race, said he did not "fully understand" why Red Bull was so fast at Interlagos.
Asked by Autosport if he shared Vettel's surprise, the third-place qualifier said: "Of course.
"We didn't expect to come here and see [this].
"On top of that, they're quickest in the middle sector, so they've obviously still got the same amount of downforce, but more power."
Verstappen downplayed his speed on the straights, pointing out Red Bull was not quickest in the final sector, which comprises a full-throttle blast on the 1.2km stretch from the penultimate corner to the finish line.
"Last year we were quite good here," said Verstappen. "But I think this year we made a step forward.
"We learned from our mistakes in some recent races and we came back stronger and everything's working well."


Pavel Iakovlev is a singer-songwriter based in Sao-Paulo, Brazil. He started his musical journey in Saint-Petersburg, Russia, playing in indie-rock bands as a guitarist. His love for travel brought him to South-East Asia and now to Latin America, inspiring him to put his experience on paper and transfer it into the sound of his debut EP ‘All The Songs For You’.
Warm and dreamy but yet melancholic sounds, mixed with the atmosphere of big city romanticism, tell a simple story of ‘boy meets girl’, and all that comes with it. It's mellow wistfulness and acoustic vibes, brought under the influence of Jeff Buckley, Damien Rice and John Frusciante, made ‘All The Songs For You’ very intimate, reflecting Pavel's inspiration with the people he met along his short, but colorful journey, both as world traveler and aspiring artist.
Don’t you wanna hear...
Don’t you wanna see...
Don’t you wanna feel...
Don’t you wanna read between the lines of
All the songs I wrote for you


An edge from 'commit' to 'push' means that you did 'git commit' right before 'git push'. Thicker edges happened more times.
The sparse version only has edges in the top 99% of transitions.


Ships
Shipping Companies
Orders
List Ships
List Shipping Companies
List Orders
Add Ship
Add Shipping Company
Create Order
Logout


If You are my legend
问题描述 :
If you are my legend——If your are my legend, let it as long as the heaven and earth endure（Sky Long Earth Nine）.
The castle is so Complex, See the figure below:
The castle surface is divided into N by M square cells. Some cubes are stacked one upon another over the cells, forming towers. For each cell the number of cubes stacked over it is given in the matrix A.
Now, give A to you , please help them construct their castle, the unit cube represented as shown below:
WhereIsHeroFrom loves a girl very much, we call her X Gu Niang. But today they can’t get together because they live in two different provinces and their distance is much farther. Now they want to build a castle for their future.
The castle surface is divided into N by M square cells. Some cubes are stacked one upon another over the cells, forming towers. For each cell the number of cubes stacked over it is given in the matrix A.
Now, give A to you , please help them construct their castle, the unit cube represented as shown below:
输入:
Input contains integers N , M, (1 <= N, M <= 30)followed by matrix A, row-by-row. The first row describes the cube tower furthest from the viewer, left to right, and the last row — nearest to the viewer.
输出:
Input contains integers N , M, (1 <= N, M <= 30)followed by matrix A, row-by-row. The first row describes the cube tower furthest from the viewer, left to right, and the last row — nearest to the viewer.
样例输入:
2 4 2 2 3 2 1 1 2 3
样例输出:
************+---+**** ***********/ /|**** **********+---+---+** ****+---+-| / /|-+ ***/ / | +---+ |/| **+---+---+-| | + | **| | / | |/| + **| | +---+---+ |/| **+---+-| | | + | */ / | | |/| + +---+---+---+---+ |/* | | | | | +** | | | | |/*** +---+---+---+---+****
(adsbygoogle = window.adsbygoogle || []).push({});
表告诉我女主还不明白男主心意..？
太好了，收藏
学习了
这个还不错
不同的编译器，printf(),执行的顺序不同，所以结果也就不同，建议不要那么写
什么破题，题意好难懂啊
第一题是不是可以这样想，生了n孩子的家庭等价于n个家庭各生了一个1个孩子，这样最后男女的比例还是1:1
顺利测试通过了，多谢
约瑟夫也用说这么长……很成熟的一个问题了，分治的方法解起来o(n)就可以了，有兴趣可以看看具体数学的第一章，关于约瑟夫问题推导出了一系列的结论，很漂亮
面霸网。www.51mx.org
分析的很详细！赞一个
第15行代码，/n/n，应该改为nn
题目和代码都不一样好吗！！！搞错了
第一句可以忽略不计了吧。从第二句开始分析，说明这个花色下的所有牌都会在其它里面出现，那么还剩下♠和♦。第三句，可以排除2和7，因为在两种花色里有。现在是第四句，因为♠还剩下多个，只有是♦B才能知道答案。
有点意思


Mini Mercury skips across sun's vast glare in rare transit: VIDEO
by Marcia DunnMini Mercury skipped across the vast, glaring face of the sun Monday in a rare celestial transit.
Stargazers used solar-filtered binoculars and telescopes to spot Mercury - a tiny black dot - as it passed directly between Earth and the sun on Monday.
The eastern U.S. and Canada got the whole 5 -hour show, weather permitting, along with Central and South America. The rest of the world, except for Asia and Australia, got just a sampling.
Mercury is the solar system's smallest, innermost planet. The next transit isn't until 2032, and North America won't get another shot until 2049.
In Maryland, clouds prevented NASA solar astrophysicist Alex Young from getting a clear peek. Live coverage was provided by observatories including NASA's orbiting Solar Dynamics Observatory.
"It's a bummer, but the whole event was still great," Young wrote in an email. "Both getting to see it from space and sharing it with people all over the country and world."
At Cape Canaveral, space buffs got a two-for-one. As Mercury's silhouette graced the morning sun, SpaceX launched 60 small satellites for global internet service, part of the company's growing Starlink constellation in orbit.


Time for a new research chem. We'd done alot of research ourselves and decided to try 5-MeO-AMT, or Alpha-O, this time based on the TiHKAL entry. Shulgin states with 4mg orally, 'A wonderful drug for interacting with others and formulating ideas. It bestows a remarkable ability to multi-task mental activities. No hang-over the next day, in fact quite the reverse. Can't wait to try 5 milligrams.' So, we tried 5mg.
After fasting for 6 hours or so, my friend (Pan) and I took our capsules at 7:30 in the evening and busied ourselves preparing the setting.
After 90 minutes we were pretty sure nothing was going to happen, but kept our hopes up and continued our conversation.
At 2 hours we both experienced a bit of gas, and mine found me hobbling off to the rest room. This guerrilla bowel movement turned out to be surprisingly pleasant. And in its midst I noticed, to my delight, that the old shaggy rug on the floor in front of me was rippling a bit. So, I finished things up in there, and went back to the room where I found that everything was glowing with that beautiful aura I see on a healthy amount of cannabis.
Conversation roared on with awesome fluency. No memory problems. No spaciness. Nothing bad at all! To celebrate this joyous moment, we smoked a bowl of very fine cannabis. This increased visual and audial hallucinations, gave us that sense of calm it always brings, and made things all the more jolly!
One interesting thing to note was that we never went into 'trip time'. I always had an approximate idea of what time it was.
A housemate came in and joined our session of free thought. It was beautiful, hedonistic jive that went on for hours. He noted that we were especially 'On the ball'.
After his departure, the trip was still raging and we layed on the ground and decided to smoke another bowl. After partaking in the sacrament, we wondered if we could take this any further. Fishing through my bag, I brought out a little sack of 10x 'Lady Salvia' Salvia Divinorum Extract (not the best I've had, but not bad). Pan took the first hit and quickly passed it on so I could catch up to surreality with him. The experience wasn't terribly different than while not tripping, but effects went well with the Alpha-O.
A couple more hours of talking later we both came down with headaches and passed out at about 5 in the morning (9.5 hours after ingestion).
This was a very social, very active trip. Anything hallucinogenic was on our terms. Not profound or heady at all, but great idea flow!!! We attributed the headaches to dehydration, seeing that we forgot to drink anything for the whole experience. Shulgin was right, I could even pull this one off at school or on the job (not that I'd recommend it)! We will definately be doing more experiments with this one.
Have fun and be safe!
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


{% extends 'administration/base_admin.html' %} {% block content %} {% load filter %}
{{ information.text | linebreaksbr }}
Another admin or user already deleted this comment!
{{ comment|get_short_text:160 }}
If you delete This Information, this data will be permanently lost.
Would you like to rethink your decision?
If you delete This Comment, the data will be permanently lost.
Would you like to rethink your decision?
Comment to: {{information.headline}}
from {{ comment.date }} / number of reports: {{ comment.number_reports }}
{{ comment.text|linebreaksbr }}
{% endautoescape %}


My
Diary
Home
About
Login here
Username
Password
Lost your password?
Don't have an account?
Register here
First Name
Last Name
Email
Password
Confirm Password
Have an account already?Sign in here


Interoperable Data Collection
We would like to announce the formation of SPLICE Working Group on Interoperable Data Collection. As a focus on standards and data interoperability gains momentum, we invite SPLICE community to take an active part in forming its agenda as well as participate in its meetings and other activities.
The focus of the group is collecting and representing heterogenous student activity traces in an industry-standard interoperable fashion that would enable collection, transfer, archival storage, sharing, and issue-free posthoc analyses. The workgroup would engage in a set of activities that target the creation of processes and deliverables addressing learning data interoperability in observance of de-facto industry standards and wide-spread solutions.
Tentative Technologies and Tools
To achieve the stated goals, the following suite of technologies and solutions is considered.
- xAPI and IMS Global Caliper as the representation of the learning data events serialized using JavaScript Object Notation (JSON).
- Callisto as a hosted Learner Record Store working with xAPI data format and supporting managed access to the data.
- Amazon Web Services as a cloud platform for hosting the Learner Record Store.
- Docker as the technology for supporting containerized development of the LRS and data stream solutions.
- Postman (optionally or complementary Apache JMeter) as the technology for testing the developed solutions via managed data-light request collections.
Proposed Activities
A working draft of activities to be carried out to complete this project is as follows.
- Hold regular meetings of the workgroup.
- Align data stream representations within the SPLICE universe to the xAPI/Caliper format. This activity focuses on creating a set of recommendations for serializing heterogeneous source data.
- Create a working example of a containerized (using Docker) and deployed (using AWS) instances of xAPI LRS.
- Create an example suite of request collections for testing the correctness of operation and integrity of the containerized/deployed xAPI LRS.
- Author and publish requirements for importing previously collected heterogeneous data streams and executing multiple sample jobs as a proof-of-concept.
All interested in the workgroup's activities please, contact the organizer, Michael Yudelson


About Me
If you're here, you're probably wanting to see what I can do...
I possess more than 5 years of progressive experience in the web development field. My professional history includes positions such as Customer Support for StoresOnline, Junior and Front-end Developer at EKR Agency as well as a variety of independent work.
My personal hobbies include gaming, both online and tabletop, reading, and drawing. More specifically of these activities, I enjoy playing RPGS, I love fantasy and sci/fi, and I like to carry a sketchbook around to doodle and write ideas in as they come to me.
I first began experimenting with web development back in 2001. I was among the first students in my school to take classes on web development and learning HTML. I have since been able to experiment and learn CSS and Javascript and jQuery through personal projects and experiments. I have also completed a course on web development through MATC.
Oh look, a list!
Areas of experience:
- CSS3
- Angular
- Javascript
- HTML5
- Jquery
- PHP
- WordPress
- GIT
- C++


Your data was uploaded and imported successfully.
Your data was uploaded successfully.
Upload a comma separated values (CSV) or tab separated values (TSV) file.


Interpretation Objects¶
Overview¶
Interpretation are initialized with a DataManager object, and expose interpretation algorithms as methods. For instance:
1 2 3 4 | from skater import Interpretation()
interpreter = Interpretation()
interpreter.load_data(data)
interpreter.feature_importance.feature_importance(model)
|
Loading Data¶
Before running interpretation algorithms on a model, the Interpretation object usually needs data, either to learn about the distribution of the training set or to pass inputs into a prediction function.
When calling Interpretation.load_data, the object creates a DataManager object, which handles the data, keeping track of feature and observation names, as well as providing various sampling algorithms.
Currently load_data requires a numpy ndarray or pandas DataFrame, though we may add support for additional data structures in the future. For more details on what the DataManager does, please see the relevant documentation [PROVIDE LINK].
-
Interpretation.
load_data
(training_data, training_labels=None, feature_names=None, index=None)¶ Creates a DataSet object from inputs, ties to interpretation object. This will be exposed to all submodules.
Parameters: - training_data: numpy.ndarray, pandas.DataFrame
the dataset. can be 1D or 2D
- feature_names: array-type
names to call features.
- index: array-type
names to call rows.
Returns: - None
Global Interpretations¶
A predictive model is a mapping from an input space to an output space. Interpretation algorithms are divided into those that offer statistics and metrics on regions of the domain, such as the marginal distribution of a feature, or the joint distribution of the entire training set. In an ideal world there would exist some representation that would allow a human to interpret a decision function in any number of dimensions. Given that we generally can only intuit visualizations of a few dimensions at time, global interpretation algorithms either aggregate or subset the feature space.
Currently, model agnostic global interpretation algorithms supported by skater include partial dependence and feature importance.
Feature Importance¶
Feature importance is generic term for the degree to which a predictive model relies on a particular feature. skater feature importance implementation is based on an information theoretic criteria, measuring the entropy in the change of predictions, given a perturbation of a given feature. The intuition is that the more a model’s decision criteria depend on a feature, the more we’ll see predictions change as a function of perturbing a feature.
Jupyter Notebooks
-
class
skater.core.global_interpretation.feature_importance.
FeatureImportance
(interpreter)¶ Contains methods for feature importance. Subclass of BaseGlobalInterpretation.
Attributes: data_set
data_set routes to the Interpreter’s dataset
training_labels
training_labels routes to the Interpreter’s training labels
Methods
feature_importance
(model_instance[, …])Computes feature importance of all features related to a model instance. load_data
(training_data[, index, feature_names]).consider routes to Interpreter’s .consider plot_feature_importance
(modelinstance[, …])Computes feature importance of all features related to a model instance, then plots the results. -
data_set
¶ data_set routes to the Interpreter’s dataset
-
feature_importance
(model_instance, ascending=True, filter_classes=None, n_jobs=-1, progressbar=True, n_samples=5000, method='prediction-variance', scorer_type='default', use_scaling=False)¶ Computes feature importance of all features related to a model instance. Supports classification, multi-class classification, and regression.
Parameters: - model_instance: skater.model.model.Model subtype
the machine learning model “prediction” function to explain, such that predictions = predict_fn(data).
- ascending: boolean, default True
Helps with ordering Ascending vs Descending
- filter_classes: array type
The classes to run partial dependence on. Default None invokes all classes. Only used in classification models.
- n_jobs: int
How many concurrent processes to use. Defaults -1, which grabs as many as are available. Use 1 to avoid multiprocessing altogether.
- progressbar: bool
Whether to display progress. This affects which function we use to operate on the pool of processes, where including the progress bar results in 10-20% slowdowns.
- n_samples: int
How many samples to use when computing importance.
- method: string (default ‘prediction-variance’; ‘model-scoring’ for estimator specific scoring metric
How to compute feature importance. ‘model-scoring’ requires Interpretation.training_labels. Note this choice should only rarely makes any significant differences prediction-variance: mean absolute value of changes in predictions, given perturbations. model-scoring: difference in log_loss or MAE of training_labels given perturbations.
- scorer_type: string
only used when method=’model-scoring’, and in this case defines which scoring function to use. Default value is ‘default’, which evaluates to:
regressors: mean absolute error classifiers with probabilities: cross entropy classifiers without probabilities: f1 score
See Skater.model.scorers for details.
- use_scaling: bool
Whether to weight the importance values by the strength of the perturbations. Generally doesn’t effect results unless n_samples is very small.
Returns: - importances : Sorted Series
References
Wei, Pengfei, Zhenzhou Lu, and Jingwen Song. “Variable Importance Analysis: A Comprehensive Review”. Reliability Engineering & System Safety 142 (2015): 399-432.
Examples
>>> from skater.model import InMemoryModel >>> from skater.core.explanations import Interpretation >>> from sklearn.ensemble import RandomForestClassifier >>> rf = RandomForestClassifier() >>> rf.fit(X,y) >>> model = InMemoryModel(rf.predict_proba, examples = X) >>> interpreter = Interpretation() >>> interpreter.load_data(X) >>> interpreter.feature_importance.feature_importance(model)
-
load_data
(training_data, index=None, feature_names=None)¶ .consider routes to Interpreter’s .consider
-
plot_feature_importance
(modelinstance, filter_classes=None, ascending=True, ax=None, progressbar=True, n_jobs=-1, n_samples=5000, method='prediction-variance', scorer_type='default', use_scaling=False)¶ Computes feature importance of all features related to a model instance, then plots the results. Supports classification, multi-class classification, and regression.
Parameters: - modelinstance: skater.model.model.Model subtype
estimator “prediction” function to explain the predictive model. Could be probability scores or target values
- filter_classes: array type
The classes to run partial dependence on. Default None invokes all classes. Only used in classification models.
- ascending: boolean, default True
Helps with ordering Ascending vs Descending
- ax: matplotlib.axes._subplots.AxesSubplot
existing subplot on which to plot feature importance. If none is provided, one will be created.
- progressbar: bool
Whether to display progress. This affects which function we use to operate on the pool of processes, where including the progress bar results in 10-20% slowdowns.
- n_jobs: int
How many concurrent processes to use. Defaults -1, which grabs as many as are available. Use 1 to avoid multiprocessing altogether.
- n_samples: int
How many samples to use when computing importance.
- method: string
How to compute feature importance. ‘model-scoring’ requires Interpretation.training_labels prediction-variance: mean absolute value of changes in predictions, given perturbations. model-scoring: difference in log_loss or MAE of training_labels given perturbations. Note this vary rarely makes any significant differences
- scorer_type: string
only used when method=’model-scoring’, and in this case defines which scoring function to use. Default value is ‘default’, which evaluates to:
regressors: mean absolute error classifiers with probabilities: cross entropy classifiers without probabilities: f1 score
See Skater.model.scorers for details.
- use_scaling: bool
Whether to weight the importance values by the strength of the perturbations. Generally doesn’t effect results unless n_samples is very small.
Returns: - f: figure instance
- ax: matplotlib.axes._subplots.AxesSubplot
could be used to for further modification to the plots
Examples
>>> from skater.model import InMemoryModel >>> from skater.core.explanations import Interpretation >>> from sklearn.ensemble import RandomForestClassifier >>> rf = RandomForestClassifier() >>> rf.fit(X,y) >>> model = InMemoryModel(rf.predict_proba, examples = X) >>> interpreter = Interpretation() >>> interpreter.load_data(X) >>> interpreter.feature_importance.plot_feature_importance(model, ascending=True, ax=ax)
-
training_labels
¶ training_labels routes to the Interpreter’s training labels
Partial Dependence¶
Partial Dependence describes the marginal impact of a feature on model prediction, holding other features in the model constant. The derivative of partial dependence describes the impact of a feature (analogous to a feature coefficient in a regression model).
Jupyter Notebooks
-
class
skater.core.global_interpretation.partial_dependence.
PartialDependence
(interpreter)¶ Contains methods for partial dependence. Subclass of BaseGlobalInterpretation
Partial dependence adapted from:
T. Hastie, R. Tibshirani and J. Friedman, Elements of Statistical Learning Ed. 2, Springer, 2009.
Attributes: data_set
data_set routes to the Interpreter’s dataset
training_labels
training_labels routes to the Interpreter’s training labels
Methods
compute_3d_gradients
(pdp, mean_col, …[, …])Computes component-wise gradients of pdp dataframe. load_data
(training_data[, index, feature_names]).consider routes to Interpreter’s .consider partial_dependence
(feature_ids, modelinstance)Approximates the partial dependence of the predict_fn with respect to the variables passed. plot_partial_dependence
(feature_ids, …[, …])Computes partial_dependence of a set of variables. feature_column_name_formatter -
static
compute_3d_gradients
(pdp, mean_col, feature_1, feature_2, scaled=True)¶ Computes component-wise gradients of pdp dataframe.
Parameters: - pdp: pandas.DataFrame
DataFrame containing partial dependence values
- mean_col: string
column name corresponding to pdp value
- feature_1: string
column name corresponding to feature 1
- feature_2: string
column name corresponding to feature 2
- scaled: bool
Whether to scale the x1 and x2 gradients relative to x1 and x2 bin sizes
Returns: - dx, dy, x_matrix, y_matrix, z_matrix
-
data_set
¶ data_set routes to the Interpreter’s dataset
-
load_data
(training_data, index=None, feature_names=None)¶ .consider routes to Interpreter’s .consider
-
partial_dependence
(feature_ids, modelinstance, filter_classes=None, grid=None, grid_resolution=30, n_jobs=-1, grid_range=None, sample=True, sampling_strategy='random-choice', n_samples=1000, bin_count=50, return_metadata=False, progressbar=True, variance_type='estimate')¶ Approximates the partial dependence of the predict_fn with respect to the variables passed.
-
plot_partial_dependence
(feature_ids, modelinstance, filter_classes=None, grid=None, grid_resolution=30, grid_range=None, n_jobs=-1, sample=True, sampling_strategy='random-choice', n_samples=1000, bin_count=50, with_variance=False, figsize=(16, 10), progressbar=True, variance_type='estimate')¶ Computes partial_dependence of a set of variables. Essentially approximates the partial partial_dependence of the predict_fn with respect to the variables passed.
Examples
>>> from sklearn.ensemble import GradientBoostingRegressor >>> from sklearn.datasets.california_housing import fetch_california_housing >>> cal_housing = fetch_california_housing() # split 80/20 train-test >>> x_train, x_test, y_train, y_test = train_test_split(cal_housing.data, >>> cal_housing.target, test_size=0.2, random_state=1) >>> names = cal_housing.feature_names >>> print("Training the estimator...") >>> estimator = GradientBoostingRegressor(n_estimators=10, max_depth=4, >>> learning_rate=0.1, loss='huber', random_state=1) >>> estimator.fit(x_train, y_train) >>> from skater.core.explanations import Interpretation >>> interpreter = Interpretation() >>> print("Feature name: {}".format(names)) >>> interpreter.load_data(X_train, feature_names=names) >>> print("Input feature name: {}".format[names[1], names[5]]) >>> from skater.model import InMemoryModel >>> model = InMemoryModel(clf.predict, examples = X_train) >>> interpreter.partial_dependence.plot_partial_dependence([names[1], names[5]], model, >>> n_samples=100, n_jobs=1)
-
training_labels
¶ training_labels routes to the Interpreter’s training labels
Local Interpretations¶
Local Interpretation could be possibly be achieved in two ways. Firstly, one could possibly approximate the behavior of a complex predictive model in the vicinity of a single input using a simple interpretable auxiliary or surrogate model (e.g. Linear Regressor). Secondly, one could use the base estimator to understand the behavior of a single prediction using intuitive approximate functions based on inputs and outputs.
Local Interpretable Model-Agnostic Explanations(LIME)¶
LIME is a novel algorithm designed by Riberio Marco, Singh Sameer, Guestrin Carlos to access the behavior of the any base estimator(model) using interpretable surrogate models (e.g. linear classifier/regressor). Such form of comprehensive evaluation helps in generating explanations which are locally faithful but may not align with the global behavior.
| Reference: | Riberio M, Singh S, Guestrin C(2016). Why Should {I} Trust You?”: Explaining the Predictions of Any Classifier (arXiv:1602.04938v3) |
|---|
-
class
skater.core.local_interpretation.lime.lime_tabular.
LimeTabularExplainer
(training_data, mode='classification', training_labels=None, feature_names=None, categorical_features=None, categorical_names=None, kernel_width=None, verbose=False, class_names=None, feature_selection='auto', discretize_continuous=True, discretizer='quartile')¶ Explains predictions on tabular (i.e. matrix) data. For numerical features, perturb them by sampling from a Normal(0,1) and doing the inverse operation of mean-centering and scaling, according to the means and stds in the training data. For categorical features, perturb by sampling according to the training distribution, and making a binary feature that is 1 when the value is the same as the instance being explained.
Methods
explain_instance
(data_row, predict_fn[, …])Generates explanations for a prediction. convert_and_round -
explain_instance
(data_row, predict_fn, labels=(1, ), top_labels=None, num_features=10, num_samples=5000, distance_metric='euclidean', model_regressor=None)¶ Generates explanations for a prediction.
First, we generate neighborhood data by randomly perturbing features from the instance (see __data_inverse). We then learn locally weighted linear models on this neighborhood data to explain each of the classes in an interpretable way (see lime_base.py).
- Args:
data_row: 1d numpy array, corresponding to a row predict_fn: prediction function. For classifiers, this should be a
function that takes a numpy array and outputs prediction probabilities. For regressors, this takes a numpy array and returns the predictions. For ScikitClassifiers, this is
classifier.predict_proba(). For ScikitRegressors, this is regressor.predict().labels: iterable with labels to be explained. top_labels: if not None, ignore labels and produce explanations for
the K labels with highest prediction probabilities, where K is this parameter.num_features: maximum number of features present in explanation num_samples: size of the neighborhood to learn the linear model distance_metric: the distance metric to use for weights. model_regressor: sklearn regressor to use in explanation. Defaults to Ridge regression in LimeBase. Must have model_regressor.coef_ and ‘sample_weight’ as a parameter to model_regressor.fit()
- Returns:
- An Explanation object (see explanation.py) with the corresponding explanations.
-
DNNs: DeepInterpreter¶
Helps in interpreting Deep Neural Network Models by computing the relevance/attribution of the output prediction of a deep network to its input features. The intention is to understand the input-output behavior of the complex network based on relevant contributing features.
Define Relevance: Also known as Attribution or Contribution. Lets define an input X = \([x1, x2, ... xn] \in R^{n}\) to a deep neural network(F) trained for binary classification (\(F(x) \mapsto [0, 1]\)). The goal of the relevance/attribution method is to compute the contribution scores of each input feature \(x_{i}\) to the output prediction. For e.g. for an image classification network, if the input \(x_{i}\) is represented as each pixel of the image, the attribution scores \((a1, ..., an) \in R^{n}\) could inform us which pixels of the image contributed in the selection of the particular class label.
-
class
skater.core.local_interpretation.dnni.deep_interpreter.
DeepInterpreter
(graph=None, session=None, log_level=30)¶ :: Experimental :: The implementation is currently experimental and might change in future Interpreter for inferring Deep Learning Models. Given a trained NN model and an input vector X, DeepInterpreter is responsible for providing relevance scores w.r.t a target class to analyze most contributing features driving an estimator’s decision for or against the respective class
Framework supported: Tensorflow(>=1.4.0) and Keras(>=2.0.8)
Parameters: - graph : tensorflow.Graph instance
- session : tensorflow.Session to execute the graph(default session: tf.get_default_session())
- log_level : int (default: _WARNING)
The log_level could be adjusted to other values as well. Check here ./skater/util/logger.py
References
[1] Ancona M, Ceolini E, Oztireli C, Gross M (ICLR, 2018). Towards better understanding of gradient-based attribution methods for Deep Neural Networks. https://arxiv.org/abs/1711.06104 (https://github.com/marcoancona/DeepExplain/blob/master/deepexplain/tensorflow/methods.py) Methods
explain
(relevance_type, output_tensor, …)Helps in computing the relevance scores for DNNs to understand the input and output behavior of the network. -
explain
(relevance_type, output_tensor, input_tensor, samples, use_case=None, **kwargs)¶ Helps in computing the relevance scores for DNNs to understand the input and output behavior of the network.
Parameters: - relevance_type: str
Currently, relevance score could be computed using e-LRP(‘elrp’) or Integrated Gradient(‘ig’). Other algorithms are under development.
- epsilon-LRP(‘eLRP’): Is recommended with Activation ops (‘ReLU’ and ‘Tanh’). Current implementation of LRP works only for images and makes use of epsilon(default: 0.0001) as a stabilizer.
- Integrated Gradient(‘ig’): Is recommended with Activation ops (‘Relu’, ‘Elu’, ‘Softplus’, ‘Tanh’, ‘Sigmoid’). It works for images and text. Optional parameters include steps(default: 100) and baseline(default: {‘image’: ‘a black image’}; {‘txt’: zero input embedding vector}) Gradient is computed by varying the input from the baseline(x’) to the provided input(x). x, x’ are element of R with n dimension —> [0,1]
- output_tensor: tensorflow.python.framework.ops.Tensor
Specify the output layer to start from
- input_tensor: tensorflow.python.framework.ops.Tensor
Specify the input layer to reach to
- samples: numpy.array
Batch of input for which explanations are desired. Note: The first dimension of the array specifies the batch size. For e.g.,
- for an image input of batch size 2: (2, 150, 150, 3) <batch_size, image_width, image_height, no_of_channels>
- for a text input of batch size 1: (1, 80) <batch_size, embedding_dimensions>
- use_case: str
Options: ‘image’ or ‘txt
- kwargs: optional
Returns: - result: numpy.ndarray
Computed relevance(contribution) score for the given input
References
[1] Bach S, Binder A, Montavon G, Klauschen F, Müller K-R, Samek W (2015) On Pixel-Wise Explanations for Non-Linear Classifier Decisions by Layer-Wise Relevance Propagation. PLoS ONE 10(7): e0130140. https://doi.org/10.1371/journal.pone.0130140 [2] Sundararajan, M, Taly, A, Yan, Q (ICML, 2017). Axiomatic Attribution for Deep Networks. http://arxiv.org/abs/1703.01365 [3] Ancona M, Ceolini E, Öztireli C, Gross M (ICLR, 2018). Towards better understanding of gradient-based attribution methods for Deep Neural Networks. https://arxiv.org/abs/1711.06104 Examples
>>> from skater.core.local_interpretation.dnni.deep_interpreter import DeepInterpreter >>> ... >>> import keras >>> from keras.datasets import mnist >>>from keras.models import Sequential, Model, load_model, model_from_yaml >>> from keras.layers import Dense, Dropout, Flatten, Activation >>> from keras.layers import Conv2D, MaxPooling2D >>> from keras import backend as K >>> import tensorflow as tf >>> import matplotlib.pyplot as plt >>> sess = tf.Session() >>> K.set_session(sess) >>> ... # Load dataset >>> # A simple network for MNIST data-set using Keras >>> model = Sequential() >>> model.add(Conv2D(32, kernel_size=(3, 3), >>> activation='relu', >>> input_shape=input_shape)) >>> model.add(Conv2D(64, (3, 3), activation='relu')) >>> model.add(MaxPooling2D(pool_size=(2, 2))) >>> model.add(Dropout(0.25)) >>> model.add(Flatten()) >>> model.add(Dense(128, activation='relu')) >>> model.add(Dropout(0.5)) >>> model.add(Dense(num_classes)) >>> model.add(Activation('softmax')) >>> ... # Compile and train the model >>> K.set_learning_phase(0) >>> with DeepInterpreter(session=K.get_session()) as di: >>> # 1. Load the persisted model >>> # 2. Retrieve the input tensor from the loaded model >>> yaml_file = open('model_sample.yaml', 'r') >>> loaded_model_yaml = yaml_file.read() >>> yaml_file.close() >>> loaded_model = model_from_yaml(loaded_model_yaml) >>> # load weights into new model >>> loaded_model.load_weights("model_mnist_cnn_3.h5") >>> print("Loaded model from disk") >>> input_tensor = loaded_model.layers[0].input >>> output_tensor = loaded_model.layers[-2].output
>>> # 3. We will using the last dense layer(pre-softmax) as the output layer >>> # 4. Instantiate a model with the new input and output tensor >>> new_model = Model(inputs=input_tensor, outputs=output_tensor) >>> target_tensor = new_model(input_tensor) >>> xs = input_x >>> ys = input_y >>> print("X shape: {}".format(xs.shape)) >>> print("Y shape: {}".format(ys.shape)) >>> # Original Predictions >>> print(loaded_model.predict_classes(xs)) >>> relevance_scores = di.explain('elrp', output_tensor=target_tensor * ys, input_tensor=input_tensor, >>> samples=xs, use_case='image')
DNNs: Layerwise Relevance Propagation(e-LRP)¶
-
class
skater.core.local_interpretation.dnni.gradient_relevance_scorer.
LRP
(output_tensor, input_tensor, samples, session, epsilon=0.0001)¶ LRP is technique to decompose the prediction(output) of a deep neural networks(DNNs) by computing relevance at each layer in a backward pass. Current implementation is computed using backpropagation by applying change rule on a modified gradient function. LRP could be implemented in different ways. This version implements the epsilon-LRP(Eq (58) as stated in [1] or Eq (2) in [2]. Epsilon acts as a numerical stabilizer.
References
[1] Bach S, Binder A, Montavon G, Klauschen F, Müller K-R, Samek W (2015) On Pixel-Wise Explanations for Non-Linear Classifier Decisions by Layer-Wise Relevance Propagation. PLoS ONE 10(7): e0130140. https://doi.org/10.1371/journal.pone.0130140 [2] Ancona M, Ceolini E, Öztireli C, Gross M: Towards better understanding of gradient-based attribution methods for Deep Neural Networks. ICLR, 2018
DNNs: Integrated Gradient¶
-
class
skater.core.local_interpretation.dnni.gradient_relevance_scorer.
IntegratedGradients
(output_tensor, input_tensor, samples, session, steps=100, baseline=None)¶ Integrated Gradient is a relevance scoring algorithm for Deep network based on final predictions to its input features. The algorithm statisfies two fundamental axioms related to relevance/attribution computation,
1.Sensitivity : For every input and baseline, if the change in one feature causes the prediction to change, then the that feature should have non-zero relevance score
2.Implementation Invariance : Compute relevance(attribution) should be identical for functionally equivalent networks.
References
[1] Sundararajan, Mukund, Taly, Ankur, Yan, Qiqi (ICML, 2017). [2] Ancona M, Ceolini E, Öztireli C, Gross M (ICLR, 2018). [3] Taly, Ankur(2017) http://theory.stanford.edu/~ataly/Talks/sri_attribution_talk_jun_2017.pdf
DNNs: Occlusion¶
-
class
skater.core.local_interpretation.dnni.perturbation_relevance_scorer.
Occlusion
(output_tensor, input_tensor, samples, current_session, **kwargs)¶ Occlusion is a perturbation based inference algorithm. Such forms of algorithm direcly computes the relevance/attribution of the input features \((X_{i})\) by systematically occluding different portions of the image (by removing, masking or altering them), then running a forward pass on the new input to produce a new output, and then measuring and monitoring the difference between the original output and new output. Perturbation based interpretation helps one to compute direct estimation of the marginal effect of a feature but the inference might be computationally expensive depending on the cardinatlity of the feature space. The choice of the baseline value while perturbing through the feature space could be set to 0, as explained in detail by Zeiler & Fergus, 2014[2].
References
[1] Ancona M, Ceolini E, Oztireli C, Gross M (ICLR, 2018). [2] Zeiler, M and Fergus, R (Springer, 2014). Visualizing and understanding convolutional networks. [3] https://github.com/marcoancona/DeepExplain/blob/master/deepexplain/tensorflow/methods.py
Global And Local Interpretations¶
Tree Surrogates (using Decision Trees)¶
-
class
skater.core.global_interpretation.tree_surrogate.
TreeSurrogate
(oracle=None, splitter='best', max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None, seed=None, max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, class_weight='balanced', presort=False, impurity_threshold=0.01)¶ :: Experimental :: The implementation is currently experimental and might change in future. The idea of using TreeSurrogates as means for explaining a model’s(Oracle or the base model) learned decision policies(for inductive learning tasks) is inspired by the work of Mark W. Craven described as the TREPAN algorithm. In this explanation learning hypothesis, the base estimator(Oracle) could be any form of supervised learning predictive models. The explanations are approximated using DecisionTrees(both for Classification/Regression) by learning decision boundaries similar to that learned by the Oracle(predictions from the base model are used for learning the DecisionTree representation). The implementation also generates a fidelity score to quantify tree based surrogate model’s approximation to the Oracle. Ideally, the score should be 0 for truthful explanation both globally and locally.
Parameters: - oracle : InMemory instance type
model instance having access to the base estimator(InMemory/DeployedModel). Currently, only InMemory is supported.
- splitter : str (default=”best”)
Strategy used to split at each the node. Supported strategies(“best” or “random”).
- max_depth : int (default=None)
Defines the maximum depth of a tree. If ‘None’ then nodes are expanded till all leaves are pure or contain less than min_samples_split samples. Deeper trees are prone to be more expensive and tend to over-fit. Pruning is a technique which could be applied to avoid over-fitting.
- min_samples_split : int/float (default=2)
Defines the minimum number of samples required to split an internal node:
- int, specifies the minimum number of samples
- float, then represents a percentage. Minimum number of samples is computed as ceil(min_samples_split*n_samples)
- min_samples_leaf : int/float (default=1)
Defines requirement for a leaf node. The minimum number of samples needed to be a leaf node:
- int, specifies the minimum number of samples
- float, then represents a percentage. Minimum number of samples is computed as `ceil(min_samples_split*n_samples)
- min_weight_fraction_leaf : float (default=0.0)
Defines requirement for a leaf node. The minimum weight percentage of the sum total of the weights of all input samples.
- max_features : int, float, string or None (default=None)
Defines number of features to consider for the best possible split:
- None, all specified features are used (oracle.feature_names)
- int, uses specified values as max_features at each split.
- float, as a percentage. Value for split is computed as int(max_features * n_features).
- “auto”, max_features=sqrt(n_features).
- “sqrt”, max_features=sqrt(n_features).
- “log2”, max_features=log2(n_features).
- seed : int, (default=None)
seed for random number generator
- max_leaf_nodes : int or None (default=None)
TreeSurrogates are constructed top-down in best first manner(best decrease in relative impurity). If None, results in maximum possible number of leaf nodes. This tends to over-fitting.
- min_impurity_decrease : float (default=0.0)
Tree node is considered for splitting if relative decrease in impurity is >= min_impurity_decrease.
- class_weight : dict, list of dicts, str (“balanced” or None) (default=”balanced”)
Weights associated with classes for handling data imbalance:
- None, all classes have equal weights
- “balanced”, adjusts the class weights automatically. Weights are assigned inversely proportional to class frequencies
n_samples / (n_classes * np.bincount(y))
- presort : bool (default=False)
Sorts the data before building surrogates trees to find the best splits. When dealing with larger datasets, setting it to True might result in increasing computation time because of the pre sorting operation.
- impurity_threshold : float (default=0.01)
Specifies the acceptable disparity between the Oracle and TreeSurrogates. The higher the difference between the Oracle and TreeSurrogate less faithful are the explanations generated.
References
[1] Mark W. Craven(1996) EXTRACTING COMPREHENSIBLE MODELS FROM TRAINED NEURAL NETWORKS (http://ftp.cs.wisc.edu/machine-learning/shavlik-group/craven.thesis.pdf) [2] Mark W. Craven and Jude W. Shavlik(NIPS, 96). Extracting Thee-Structured Representations of Thained Networks (https://papers.nips.cc/paper/1152-extracting-tree-structured-representations-of-trained-networks.pdf) [3] DecisionTreeClassifier: http://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html [4] DecisionTreeRegressor: http://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeRegressor.html Examples
>>> from skater.core.explanations import Interpretation >>> from skater.model import InMemoryModel >>> from skater.util.logger import _INFO >>> interpreter = Interpretation(X_train, feature_names=iris.feature_names) >>> model_inst = InMemoryModel(clf.predict, examples=X_train, model_type='classifier', unique_values=[0, 1], >>> feature_names=iris.feature_names, target_names=iris.target_names, log_level=_INFO) >>> # Using the interpreter instance invoke call to the TreeSurrogate >>> surrogate_explainer = interpreter.tree_surrogate(oracle=model_inst, seed=5) >>> surrogate_explainer.fit(X_train, y_train, use_oracle=True, prune='post', scorer_type='default') >>> surrogate_explainer.plot_global_decisions(colors=['coral', 'lightsteelblue','darkkhaki'], >>> file_name='simple_tree_pre.png') >>> show_in_notebook('simple_tree_pre.png', width=400, height=300)
Attributes: - oracle : skater.model.local_model.InMemoryModel
The fitted base model with the prediction function
- feature_names: list of str
Names of the features considered.
estimator_
: DecisionTreeClassifier/DecisionTreeRegressorLearned approximate surrogate estimator
estimator_type_
: strEstimator type
best_score_
: numpy.float64Best score post pre-pruning
scorer_name_
: strCost function used for optimization
Methods
decisions_as_txt
([scope, X])Retrieve the decision policies as text fit
(X, Y[, use_oracle, prune, cv, …])Learn an approximate representation by constructing a Decision Tree based on the results retrieved by querying the Oracle(base model). plot_global_decisions
([colors, …])Visualizes the decision policies of the surrogate tree. predict
(X[, prob_score])Predict for input X -
best_score_
¶ Best score post pre-pruning
-
decisions_as_txt
(scope='global', X=None)¶ Retrieve the decision policies as text
-
estimator_
¶ Learned approximate surrogate estimator
-
estimator_type_
¶ Estimator type
-
fit
(X, Y, use_oracle=True, prune='post', cv=5, n_iter_search=10, scorer_type='default', n_jobs=1, param_grid=None, impurity_threshold=0.01, verbose=False)¶ Learn an approximate representation by constructing a Decision Tree based on the results retrieved by querying the Oracle(base model). Instances used for training should belong to the base learners instance space.
Parameters: - X : numpy.ndarray, pandas.DataFrame
Training input samples
- Y : numpy.ndarray, target values(ground truth)
- use_oracle : bool (defaul=True)
Use of Oracle, helps the Surrogate model train on the decision boundaries learned by the base model. The closer the surrogate model is to the Oracle, more faithful are the explanations.
- True, builds a surrogate model against the predictions of the base model(Oracle).
- False, learns an interpretable tree based model using the supplied training examples and ground truth.
- prune : None, str (default=”post”)
Pruning is a useful technique to control the complexity of the tree (keeping the trees comprehensive and interpretable) without compromising on model’s accuracy. Avoiding to build large and deep trees also helps in preventing over-fitting.
- “pre”
Also known as forward/online pruning. This pruning process uses a termination condition(high and low thresholds) to prematurely terminate some of the branches and nodes. Cross Validation is applied to measure the goodness of the fit while the tree is pruned.
- “pos”
Also known as backward pruning. The pruning process is applied post the construction of the tree using the specified model parameters. This involves reducing the branches and nodes using a cost function. The current implementation support cost optimization using Model’s scoring metrics(e.g. r2, log-loss, f1, …).
- cv : int, (default=5)
Randomized cross validation used only for ‘pre-pruning’ right now.
- n_iter_search : int (default=10)
Number of parameter setting combinations that are sampled for pre-pruning.
- scorer_type : str (default=”default”)
- n_jobs : int (default=1)
Number of jobs to run in parallel.
- param_grid : dict
Dictionary of parameters to specify the termination condition for pre-pruning.
- impurity_threshold : float (default=0.01)
Specifies acceptable performance drop when using Tree based surrogates to replicate the decision policies learned by the Oracle
- verbose : bool (default=False)
Helps control the verbosity.
References
[1] Nikita Patel and Saurabh Upadhyay(2012) Study of Various Decision Tree Pruning Methods with their Empirical Comparison in WEKA (https://pdfs.semanticscholar.org/025b/8c109c38dc115024e97eb0ede5ea873fffdb.pdf)
-
plot_global_decisions
(colors=None, enable_node_id=True, random_state=0, file_name='interpretable_tree.png', show_img=False, fig_size=(20, 8))¶ Visualizes the decision policies of the surrogate tree.
-
predict
(X, prob_score=False)¶ Predict for input X
-
scorer_name_
¶ Cost function used for optimization
Bayesian Rule Lists(BRL)¶
-
class
skater.core.global_interpretation.interpretable_models.brlc.
BRLC
(iterations=30000, pos_sign=1, neg_sign=0, min_rule_len=1, max_rule_len=8, min_support_pos=0.1, min_support_neg=0.1, eta=1.0, n_chains=10, alpha=1, lambda_=10, discretize=True, drop_features=False)¶ :: Experimental :: The implementation is currently experimental and might change in future
BRLC(Bayesian Rule List Classifier) is a python wrapper for SBRL(Scalable Bayesian Rule list). SBRL is a scalable Bayesian Rule List. It’s a generative estimator to build hierarchical interpretable decision lists. This python wrapper is an extension to the work done by Professor Cynthia Rudin, Benjamin Letham, Hongyu Yang, Margo Seltzer and others. For more information check out the reference section below.
Parameters: - iterations : int (default=30000)
number of iterations for each MCMC chain.
- pos_sign : int (default=1)
sign for the positive labels in the “label” column.
- neg_sign : int (default=0)
sign for the negative labels in the “label” column.
- min_rule_len : int (default=1)
minimum number of cardinality for rules to be mined from the data-frame.
- max_rule_len : int (default=8)
maximum number of cardinality for rules to be mined from the data-frame.
- min_support_pos : float (default=0.1)
a number between 0 and 1, for the minimum percentage support for the positive observations.
- min_support_neg : float (default 0.1)
a number between 0 and 1, for the minimum percentage support for the negative observations.
- eta : int (default=1)
a hyper-parameter for the expected cardinality of the rules in the optimal rule list.
- n_chains : int (default=10)
number of chains
- alpha : int (default=1)
a prior pseudo-count for the positive(alpha1) and negative(alpha0) classes. Default values (1, 1)
- lambda_ : int (default=8)
a hyper-parameter for the expected length of the rule list.
- discretize : bool (default=True)
apply discretizer to handle continuous features.
- drop_features : bool (default=False)
once continuous features are discretized, use this flag to either retain or drop them from the dataframe
References
[1] Letham et.al(2015) Interpretable classifiers using rules and Bayesian analysis: Building a better stroke prediction model (https://arxiv.org/abs/1511.01644) [2] Yang et.al(2016) Scalable Bayesian Rule Lists (https://arxiv.org/abs/1602.08610) [3] https://github.com/Hongyuy/sbrl-python-wrapper/blob/master/sbrl/C_sbrl.py Examples
>>> from skater.core.global_interpretation.interpretable_models.brlc import BRLC >>> import pandas as pd >>> from sklearn.datasets.mldata import fetch_mldata >>> input_df = fetch_mldata("diabetes") ... >>> Xtrain, Xtest, ytrain, ytest = train_test_split(input_df, y, test_size=0.20, random_state=0) >>> sbrl_model = BRLC(min_rule_len=1, max_rule_len=10, iterations=10000, n_chains=20, drop_features=True) >>> # Train a model, by default discretizer is enabled. So, you wish to exclude features then exclude them using >>> # the undiscretize_feature_list parameter >>> model = sbrl_model.fit(Xtrain, ytrain, bin_labels="default") >>> #print the learned model >>> sbrl_inst.print_model() >>> features_to_descritize = Xtrain.columns >>> Xtrain_filtered = sbrl_model.discretizer(Xtrain, features_to_descritize, labels_for_bin="default") >>> predict_scores = sbrl_model.predict_proba(Xtest) >>> _, y_hat = sbrl_model.predict(Xtest) >>> # save and reload the model and continue with evaluation >>> sbrl_model.save_model("model.pkl") >>> sbrl_model.load_model("model.pkl") >>> # to access all the learned rules >>> sbrl_model.access_learned_rules("all") # For a complete example refer to rule_lists_continuous_features.ipynb or rule_lists_titanic_dataset.ipynb notebook
Methods
access_learned_rules
([rule_indexes])Access all learned decision rules. discretizer
(X, column_list[, …])A discretizer for continuous features filter_to_be_discretize
(clmn_list, unwanted_list)fit
(X, y_true[, n_quantiles, bin_labels, …])Fit the estimator. load_model
(serialized_model_name)Load a serialized model predict
([X, prob_score, threshold, pos_label])Predict the class for input ‘X’ The predicted class is determined by setting a threshold. predict_proba
(X)Computes possible class probabilities for the input ‘X’ print_model
()print the decision stumps of the learned estimator save_model
(model_name[, compress])Persist the model for future use set_params
(params)Set model hyper-parameters -
access_learned_rules
(rule_indexes='all')¶ Access all learned decision rules. This is useful for building and developing intuition
Parameters: - rule_indexes: str (default=”all”, retrieves all the rules)
Specify the index of the rules to be retrieved index could be set as ‘all’ or a range could be specified e.g. ‘(1:3)’ will retrieve the rules 1 and 2
-
discretizer
(X, column_list, no_of_quantiles=None, labels_for_bin=None, precision=3)¶ A discretizer for continuous features
Parameters: - X : pandas.DataFrame
Dataframe containing continuous features
- column_list : list/tuple
- no_of_quantiles : int or list
Number of quantiles, e.g. deciles(10), quartiles(4) or as a list of quantiles[0, .25, .5, .75, 1.] if ‘None’ then [0, .25, .5, .75, 1.] is used
- labels_for_bin : labels for the resulting bins
- precision : int
precision for storing and creating bins
Returns: - new_X: pandas.DataFrame
Contains discretized features
Examples
>>> sbrl_model = BRLC(min_rule_len=1, max_rule_len=10, iterations=10000, n_chains=20, drop_features=True) >>> ... >>> features_to_descritize = Xtrain.columns >>> Xtrain_discretized = sbrl_model.discretizer(Xtrain, features_to_descritize, labels_for_bin="default") >>> predict_scores = sbrl_model.predict_proba(Xtrain_discretized)
-
fit
(X, y_true, n_quantiles=None, bin_labels='default', undiscretize_feature_list=None, precision=3)¶ Fit the estimator.
Parameters: - X : pandas.DataFrame object, that could be used by the model for training.
It must not have a column named ‘label’
y_true : pandas.Series, 1-D array to store ground truth labels
Returns: - SBRL model instance: rpy2.robjects.vectors.ListVector
Examples
>>> from skater.core.global_interpretation.interpretable_models.brlc import BRLC >>> sbrl_model = BRLC(min_rule_len=1, max_rule_len=10, iterations=10000, n_chains=20, drop_features=True) >>> # Train a model, by default discretizer is enabled. So, you wish to exclude features then exclude them using >>> # the undiscretize_feature_list parameter >>> model = sbrl_model.fit(Xtrain, ytrain, bin_labels="default")
-
load_model
(serialized_model_name)¶ Load a serialized model
-
predict
(X=None, prob_score=None, threshold=0.5, pos_label=1)¶ Predict the class for input ‘X’ The predicted class is determined by setting a threshold. Adjust threshold to balance between sensitivity and specificity
Parameters: - X: pandas.DataFrame
input examples to be scored
- prob_score: pandas.DataFrame or None (default=None)
If set to None, predict_proba is called before computing the class labels. If you have access to probability scores already, use the dataframe of probability scores to compute the final class label
- threshold: float (default=0.5)
- pos_label: int (default=1)
specify how to identify positive label
Returns: - y_prob, y_prob[‘label]: pandas.Series, numpy.ndarray
Contains the probability score for the input ‘X’
-
predict_proba
(X)¶ Computes possible class probabilities for the input ‘X’
Parameters: - X: pandas.DataFrame object
Returns: - pandas.DataFrame of shape (#datapoints, 2), the possible probability of each class for each observation
-
print_model
()¶ print the decision stumps of the learned estimator
-
save_model
(model_name, compress=True)¶ Persist the model for future use
-
set_params
(params)¶ Set model hyper-parameters
-
class
skater.core.global_interpretation.interpretable_models.bigdatabrlc.
BigDataBRLC
(sub_sample_percentage=0.1, iterations=30000, pos_sign=1, neg_sign=0, min_rule_len=1, max_rule_len=8, min_support_pos=0.1, min_support_neg=0.1, eta=1.0, n_chains=10, alpha=1, lambda_=8, discretize=True, drop_features=False, threshold=0.5, penalty_param_svm=0.01, calibration_type='sigmoid', cv_calibration=3, random_state=0, surrogate_estimator='SVM')¶ :: Experimental :: The implementation is currently experimental and might change in future
BigDataBRLC is a BRLC to handle large data-sets. Advisable to be used when the number of input examples>1k. It approximates large datasets with the help of surrogate(metamodel) estimators. For example, it uses surrogate estimator such as SVC(Support Vector Classifier) or RandomForest by default to filter the data points which are closest to the decision boundary. The idea is to identify the minimum training set size (controlled by the parameter sub_sample_percentage) with the goal to maximize accuracy. This helps in reducing the computation time to build the final BRL.
Parameters: - sub_sample_percentage : float (default=0.1)
specify the fraction of the training sample to be retained for training BRL.
- iterations : int (default=30000)
number of iterations for each MCMC chain.
- pos_sign : int (default=1)
sign for the positive labels in the “label” column.
- neg_sign : int (default=0)
sign for the negative labels in the “label” column.
- min_rule_len : int (default=1)
minimum number of cardinality for rules to be mined from the data-frame.
- max_rule_len : int (default=8)
maximum number of cardinality for rules to be mined from the data-frame.
- min_support_pos : float (default=0.1)
a number between 0 and 1, for the minimum percentage support for the positive observations.
- min_support_neg : float (default 0.1)
a number between 0 and 1, for the minimum percentage support for the negative observations.
- eta : int (default=1)
- n_chains: int (default=10)
- alpha : int (default=1)
a prior pseudo-count for the positive(alpha1) and negative(alpha0) classes. Default values (1, 1)
- lambda_ : int (default=8)
a hyper-parameter for the expected length of the rule list.
- discretize : bool (default=True)
apply discretizer to handle continuous features.
- drop_features : bool (default=False)
once continuous features are discretized, use this flag to either retain or drop them from the dataframe
- threshold : float (default=0.5)
specify the threshold for the decision boundary. This is the probability level to compute distance of the predictions(for input examples) from the decision boundary. Input examples closest to the decision boundary are sub-sampled. Size of sub-sampled data is controlled using ‘sub_sample_percentage’.
- penalty_param_svm : float (default=0.01)
Regularization parameter(‘C’) for Linear Support Vector Classifier. Lower regularization value forces the optimizer to maximize the hyperplane.
References: https://stats.stackexchange.com/questions/31066/what-is-the-influence-of-c-in-svms-with-linear-kernel
- calibration_type : string (default=’sigmoid’)
Calibrate the base estimator’s prediction(currently, all the base estimators are calibrated, that might change in future with more experimentation). Calibration could be performed in 2 ways 1. parametric approach using Platt Scaling (‘sigmoid’) 2. non-parametric approach using isotonic regression(‘isotonic). Avoid using isotonic regression for input examples<<1k because it tends to over-fit.
References:
[1] A. Niculescu-Mizil & R. Caruana(ICML2005), Predicting Good Probabilities With Supervised Learning
[2] https://www.cs.cornell.edu/~alexn/papers/calibration.icml05.crc.rev3.pdf
[3] http://fastml.com/classifier-calibration-with-platts-scaling-and-isotonic-regression/
- cv_calibration : int (default=3)
specify number of folds for cross-validation splitting strategy
- random_state: int (default=0)
- surrogate_estimator: string (default=’SVM’, ‘RF’: RandomForest)
Surrogate model to build the initial model for handling large datasets. Currently, SVM and RandomForest is supported.
References
[1] Dr. Tamas Madl, https://github.com/tmadl/sklearn-expertsys/blob/master/BigDataRuleListClassifier.py [2] https://pdfs.semanticscholar.org/e44c/9dcf90d5a9a7e74a1d74c9900ff69142c67f.pdf [3] Surrogate model: https://en.wikipedia.org/wiki/Surrogate_model [4] W. Andrew Pruett , Robert L. Hester(2016), The Creation of Surrogate Models for Fast Estimation of Complex Model Outcomes (http://journals.plos.org/plosone/article?id=10.1371/journal.pone.0156574) Examples
>>> from skater.core.global_interpretation.interpretable_models.brlc import BRLC >>> from skater.core.global_interpretation.interpretable_models.bigdatabrlc import BigDataBRLC >>> import pandas as pd >>> from sklearn.model_selection import train_test_split ... >>> Xtrain, Xtest, ytrain, ytest = train_test_split(X, y) >>> input_df = pd.read_csv('input_data.csv', skiprows=1) >>> sbrl_big = BigDataBRLC(sub_sample_percentage=0.1, min_rule_len=1, max_rule_len=3, iterations=10000, ... n_chains=3, surrogate_estimator="SVM", drop_features=True) >>> n_x, n_y = sbrl_big.subsample(Xtrain, ytrain, pos_label=1) >>> model = sbrl_big.fit(n_x, n_y, bin_labels='default') # For a complete example refer to credit_analysis_rule_lists.ipynb notebook in the `examples` section
Methods
access_learned_rules
([rule_indexes])Access all learned decision rules. discretizer
(X, column_list[, …])A discretizer for continuous features filter_to_be_discretize
(clmn_list, unwanted_list)fit
(X, y_true[, n_quantiles, bin_labels, …])Fit the estimator. load_model
(serialized_model_name)Load a serialized model predict
([X, prob_score, threshold, pos_label])Predict the class for input ‘X’ The predicted class is determined by setting a threshold. predict_proba
(X)Computes possible class probabilities for the input ‘X’ print_model
()print the decision stumps of the learned estimator save_model
(model_name[, compress])Persist the model for future use set_params
(params)Set model hyper-parameters subsample
(X, y[, pos_label, neg_label])subsampler to filter the input examples closer to the decision boundary -
access_learned_rules
(rule_indexes='all')¶ Access all learned decision rules. This is useful for building and developing intuition
Parameters: - rule_indexes: str (default=”all”, retrieves all the rules)
Specify the index of the rules to be retrieved index could be set as ‘all’ or a range could be specified e.g. ‘(1:3)’ will retrieve the rules 1 and 2
-
discretizer
(X, column_list, no_of_quantiles=None, labels_for_bin=None, precision=3)¶ A discretizer for continuous features
Parameters: - X : pandas.DataFrame
Dataframe containing continuous features
- column_list : list/tuple
- no_of_quantiles : int or list
Number of quantiles, e.g. deciles(10), quartiles(4) or as a list of quantiles[0, .25, .5, .75, 1.] if ‘None’ then [0, .25, .5, .75, 1.] is used
- labels_for_bin : labels for the resulting bins
- precision : int
precision for storing and creating bins
Returns: - new_X: pandas.DataFrame
Contains discretized features
Examples
>>> sbrl_model = BRLC(min_rule_len=1, max_rule_len=10, iterations=10000, n_chains=20, drop_features=True) >>> ... >>> features_to_descritize = Xtrain.columns >>> Xtrain_discretized = sbrl_model.discretizer(Xtrain, features_to_descritize, labels_for_bin="default") >>> predict_scores = sbrl_model.predict_proba(Xtrain_discretized)
-
fit
(X, y_true, n_quantiles=None, bin_labels='default', undiscretize_feature_list=None, precision=3)¶ Fit the estimator.
Parameters: - X : pandas.DataFrame object, that could be used by the model for training.
It must not have a column named ‘label’
y_true : pandas.Series, 1-D array to store ground truth labels
Returns: - SBRL model instance: rpy2.robjects.vectors.ListVector
Examples
>>> from skater.core.global_interpretation.interpretable_models.brlc import BRLC >>> sbrl_model = BRLC(min_rule_len=1, max_rule_len=10, iterations=10000, n_chains=20, drop_features=True) >>> # Train a model, by default discretizer is enabled. So, you wish to exclude features then exclude them using >>> # the undiscretize_feature_list parameter >>> model = sbrl_model.fit(Xtrain, ytrain, bin_labels="default")
-
load_model
(serialized_model_name)¶ Load a serialized model
-
predict
(X=None, prob_score=None, threshold=0.5, pos_label=1)¶ Predict the class for input ‘X’ The predicted class is determined by setting a threshold. Adjust threshold to balance between sensitivity and specificity
Parameters: - X: pandas.DataFrame
input examples to be scored
- prob_score: pandas.DataFrame or None (default=None)
If set to None, predict_proba is called before computing the class labels. If you have access to probability scores already, use the dataframe of probability scores to compute the final class label
- threshold: float (default=0.5)
- pos_label: int (default=1)
specify how to identify positive label
Returns: - y_prob, y_prob[‘label]: pandas.Series, numpy.ndarray
Contains the probability score for the input ‘X’
-
predict_proba
(X)¶ Computes possible class probabilities for the input ‘X’
Parameters: - X: pandas.DataFrame object
Returns: - pandas.DataFrame of shape (#datapoints, 2), the possible probability of each class for each observation
-
print_model
()¶ print the decision stumps of the learned estimator
-
save_model
(model_name, compress=True)¶ Persist the model for future use
-
set_params
(params)¶ Set model hyper-parameters
-
subsample
(X, y, pos_label=1, neg_label=0)¶ subsampler to filter the input examples closer to the decision boundary
Parameters: - X : pandas.DataFrame
input examples representing the training set
- y : pandas.DataFrame
target labels associated with the training set
- pos_label : int
- neg_label : int
Returns: - X_, y_ : pandas.dataframe
- sub-sampled input examples


Because we’re getting ready for the final release, we’re removing a few things we don’t expect to ship to everyone. So starting with the next build, the Insider Hub will no longer be pre-installed. Windows Insiders can reinstall the Insider Hub app through the following steps:
- Go to Settings, System, Apps & features
- Click Manage optional features then Add a feature
- Select the Insider Hub entry (the list is in alphabetical order) and click Install.
You will have to go through this process with each build we flight prior to the final release on July 29th, but once we start flighting new builds after July 29th it will be preinstalled again.
The Windows Feedback app will continue to be included in builds and in the final release. But as I noted above, the Windows Feedback app will have functionality specific to Windows Insiders who are registered for the program with their MSA connected to their PC.


How to drive value through sophisticated martech integrations
This webinar explains how integrating different martech solutions enables brands to unite data sources and metrics and arrive at a single source of insight.
Brought to you by Decibel
20 Nov 2019 2:28 pm
Data is king. It helps us understand the online and offline experiences our customers are having and exactly how we can improve them. But the real value lies in uniting many data sources and metrics to arrive at a single source of truth.
In a new Marketing Week webinar Anthony Gribbon, journey analytics manager at LV=, shares his experience of integrating martech solutions, including Google Analytics and A/B testing tools, with digital experience insights from Decibel and using them to make changes and drive results.
LV= General Insurance is one of the UK’s largest personal lines insurers with over 5 million customers. It provides car, home, pet, travel and landlord insurance, and offers services directly to consumers as well as through intermediaries, such as brokers.


| Modifier and Type | Method and Description |
|---|---|
org.jocl.Pointer |
allocate(long size)
Allocates
size bytes of memory on the device. |
boolean |
available(Buffer buffer)
Whether the buffer is available on the device.
|
boolean |
available(byte[] a)
Whether the array of bytes is available on the device.
|
boolean |
available(double[] a)
Whether the array of doubles is available on the device.
|
boolean |
available(float[] a)
Whether the array of floats is available on the device.
|
boolean |
available(int[] a)
Whether the array of ints is available on the device.
|
int |
clean(Buffer buffer)
Clean
Buffer from the device. |
int |
clean(byte[] a)
Clean the byte array from the device.
|
int |
clean(double[] a)
Clean the double array from the device.
|
int |
clean(float[] a)
Clean the float array from the device.
|
int |
clean(int[] a)
Clean the int array from the device.
|
int |
compareTo(Device device)
Compares this device with
Device device in terms of when a device can launch kernels. |
void |
copy(Buffer buffer,
Argument.Direction d)
Copy a buffer to the device.
|
void |
copy(Buffer from,
org.jocl.Pointer to)
Copy a buffer to memory on the device.
|
void |
copy(byte[] a,
Argument.Direction d)
Copy an array of bytes to the device.
|
void |
copy(double[] a,
Argument.Direction d)
Copy an array of doubles to the device.
|
void |
copy(float[] a,
Argument.Direction d)
Copy an array of floats to the device.
|
void |
copy(int[] a,
Argument.Direction d)
Copy an array of ints to the device.
|
void |
get(Buffer buffer)
Get the
Buffer from the device. |
void |
get(Buffer to,
org.jocl.Pointer from)
Get the contents of the memory on the device represented by
Pointer from into to . |
void |
get(byte[] a)
Get the array of bytes from the device.
|
void |
get(double[] a)
Get the array of doubles from the device.
|
void |
get(double[] to,
org.jocl.Pointer from)
Get the contents of the memory on the device represented by
Pointer from into to . |
void |
get(float[] a)
Get the array of floats from the device.
|
void |
get(float[] to,
org.jocl.Pointer from)
Get the contents of the memory on the device represented by
Pointer from into to . |
void |
get(int[] a)
Get the array of ints from the device.
|
long |
getMemoryCapacity()
Get the memory capacity of this device.
|
java.lang.String |
toString()
Returns the nickname of this device.
|
public long getMemoryCapacity()
public int compareTo(Device device)
Device
device in terms of when a device can launch kernels.
This method compares the number of kernel launches on a device to find out when a device is going to terminate.
compareTo
in interface java.lang.Comparable<Device>
device
- the device to compare againstpublic java.lang.String toString()
toString
in class java.lang.Object
public org.jocl.Pointer allocate(long size)
size
bytes of memory on the device.size
- the number of bytes to allocatePointer
to the memory on the devicepublic void copy(Buffer buffer, Argument.Direction d)
get(Buffer)
.buffer
- a Buffer
to be copied to the deviced
- indicates the direction of the copied value (only for reading, only for writing, or for both)public void copy(float[] a, Argument.Direction d)
get(float[])
.a
- a float
array to be copied to the devied
- indicates the direction of the copied value (only for reading, only for writing, or for both)public void copy(double[] a, Argument.Direction d)
get(double[])
.a
- a double
array to be copied to the devied
- indicates the direction of the copied value (only for reading, only for writing, or for both)public void copy(int[] a, Argument.Direction d)
get(int[])
.a
- a int
array to be copied to the devied
- indicates the direction of the copied value (only for reading, only for writing, or for both)public void copy(byte[] a, Argument.Direction d)
get(byte[])
.a
- a byte
array to be copied to the devied
- indicates the direction of the copied value (only for reading, only for writing, or for both)public void copy(Buffer from, org.jocl.Pointer to)
copy(Buffer,Argument.Direction)
, this version is not coupled
with from
.from
- a Buffer
to be copied to the deviceto
- a Pointer
representing the address of the memory to which is copiedpublic boolean available(Buffer buffer)
buffer
- the Buffer
of which is checked to be available on the devicepublic boolean available(float[] a)
a
- the array of which is checked to be available on the devicepublic boolean available(byte[] a)
a
- the array of which is checked to be available on the devicepublic boolean available(int[] a)
a
- the array of which is checked to be available on the devicepublic boolean available(double[] a)
a
- the array of which is checked to be available on the devicepublic void get(Buffer buffer)
Buffer
from the device. The Buffer
is not removed from the device.buffer
- a Buffer
in which the datapublic void get(float[] a)
a
- the float
array to which the contents of the device representation is copiedpublic void get(double[] a)
a
- the double
array to which the contents of the device representation is copiedpublic void get(int[] a)
a
- the int
array to which the contents of the device representation is copiedpublic void get(byte[] a)
a
- the byte
array to which the contents of the device representation is copiedpublic void get(Buffer to, org.jocl.Pointer from)
Pointer
from
into to
.to
- the Buffer
to copy tofrom
- the memory from which is copiedpublic void get(double[] to, org.jocl.Pointer from)
Pointer
from
into to
.to
- the array of doubles to copy tofrom
- the memory from which is copiedpublic void get(float[] to, org.jocl.Pointer from)
Pointer
from
into to
.to
- the array of floats to copy tofrom
- the memory from which is copiedpublic int clean(Buffer buffer)
Buffer
from the device.buffer
- the Buffer
to be cleanedBuffer
valuepublic int clean(float[] a)
a
- the array to be cleanedpublic int clean(byte[] a)
a
- the array to be cleanedpublic int clean(int[] a)
a
- the array to be cleanedpublic int clean(double[] a)
a
- the array to be cleaned


UCLA's Society of Physics Students (SPS) is both an academic and social club where students from various disciplines who are interested in physics or physics-related activities come together to explore new things and have fun.
We meet on Tuesday evening at 6pm in Knudsen 2-222 during ODD weeks (week 1, 3, 5...) of the Fall, Spring, and Winter quarters. Free food is provided! There is nothing to sign up for; everyone, including non-physics majors, is welcome!
Visit our Updates page for latest events! You can also join our mailing list to get notified for club meetings.
Email<EMAIL_ADDRESS>for any questions, we'll get back to you ASAP. Officers can be most effectively found at SPS FB Group.


Specify the HTTP URL (for example http://your_server:8080)
Your access method is Direct, this means the URL needs to be accessible from the browser. Your access method is currently Proxy, this means the URL needs to be accessible from the grafana backend.


{% extends "wiki/create_root.html" %} {% load i18n wiki_tags %} {% block wiki_contents %}
{% trans "You have django-wiki installed and it seems to be working. But there are no articles yet." %}
{% if not user.is_superuser %}{% trans "Not to worry! You simply have to login with a superuser account and create the first article in the root of the URL hierarchy." %}
{% login_url as wiki_login_url %} {% if wiki_login_url %} {% trans "Click here to login" %} {% endif %} {% else %}{% trans "But since you're logged in as a superuser, we should really get started..." %}
{% trans "Yes, I'll go and create the first article" %} {% trans "No thanks, I'd rather read the documentation" %} {% endif %}


Are you sure you want to delete the application {{ application.name }} and all associated interfaces?


What are the benefits of version control? the benefits of version control is by letting you try and error with the code without the danger that you will harm the original code. how can you ever try something new if you won’t have version control? Properly you won’t. Version control is giving the artist the option to fill confident and good the right environment that he need in order to crate art. Imagine that the artist was holding a brush in his hand, thinking what to paint, looking on the naked canvas in front of him and instead of start coloring, he is only afraid to harm the older painting or damage his old art. This is where version control kick in. it let you go wild, experiment, try something new.
How does git help you keep track of changes? Git helps you keep track on the changing by saving each one of them, and saving them as rough draft until they are ready. Git will save each rough draft in your computer until they are ready to move to the next stage. It is good to know that it is on your computer, and nobody can see, and you are the only one that have access to that.
Why use GitHub to store your code? Without any doubt, Github is strong instrument that help communicate between different developer, and shows your ideas, your art, and create a conversation between developer about the code. In this way, people can be inspire, or can have access to new ideas, or find others that have the missing part that they don’t have. developers can also value other on the good of their work, and how good they code.


SoMe Social Media Strategy App - Back End
Co-creator of an extensive web back-end written in Node.JS for use by the SoMe social media planner app. After making a SoMe account, users can link a personal Twitter account. From there they are able to create, draft, post, and even schedule Tweets in advance for their social media page's needs. Includes user authentication, password hashing, real time Twitter feed, as well as full integration with the Okta secure authentication API. Created with Node.JS, Knex, and Postgres.


Romanticism in America
dale
Spring 2021
Created: 2021-02-18 Thu 11:49
Romantic challenge fo rationalism
- Unitarians: William Ellery Channing
- accomodating "biblical" teaching with rationalist approach to interpretation
- Transcendentalists: Ralph Waldo Emerson
- appealed to inner life, intuition … "I don't need to turn to the Bible to find revelation, I can look within myself."
Seeking to return American church to founding principles of Reformation
- Nevin & Schaff (transform humanity – not individuals)
- Horace Bushnell (attacking individualism of revivals)
- influenced the developing Sunday School movement
- the experience of the Civil War and the confrontation with slavery led to a need for corporate atonement, not just individual
Slavery & Black Religion
- Bushnell concern for the morality of slavery emphasizes the need account for the "full consequences of slavery and non-emancipation"
- American slavery was distinctive in identifying slavery with race
- evangelicals in England, Quakers in America led opposition to slavery
- Black identification with the freeing of the Israelites in the Exodus and the unjust suffering of Jesus on the cross
- Slavery represents in the strongest terms the unfulfilled dream of the city on a hill
- the unfulfilled dream of Puritan America
PBS special
A valuable recent production on PBS gives an overview of the Black Church experience in 4 hours
Liberation theology of the later 20th c.
- James Cone and Black Theology
- W. E. B. Du Bois
- Martin Luther King Jr.
- South Africa experience (Koinonia movement)
Ongoing issues left over from 18th c.
- How do politics and science affect theology? (206)
- distrust of authority
- Reason vs. Enthusiasm
- challenge of slavery to American experience


This sample showcases basic Voice Synthesis functionality in Windows, using WinRT APIs to convert SSML to speech


--- layout: post title: Approval for sequencing additional Plasmodium isolates and species. category: [PlasmoDB] --- The proposal for sequencing of additional Plasmodium isolates and species has been approved. The whitepaper is available here.


Details
| Features |
|
| State |
|
| Consumers |
|
| Policy |
|
| Operator policy |
|
| Effective policy definition |
|
Messages
|
Count |
Bytesize |
Average |
| Total |
|
|
|
| Ready |
|
|
|
| Unacked |
|
|
|
Consumers
| Channel |
Consumer tag |
Ack required |
Exclusive |
Prefetch count |
|
Bindings
| From |
Routing key |
Arguments |
|
The server reported messages remaining.
| Exchange |
|
| Routing key |
|
| Redelivered |
|
| Properties |
|
|
Payload
bytes
Encoding:
|
|
Pause Queue
Pausing a queue will stop deliveries to all consumers.
Delete queue
Message size snapshot
Snapshot taken at: -
|
Count |
Bytesize |
Average |
Max |
Min |
| Total |
- |
- |
- |
- |
- |
| Ready |
- |
- |
- |
- |
- |
| Unacked |
- |
- |
- |
- |
- |


Class BaseSimulation
The base simulation.
Inherited Members
Namespace: SpiceSharp.Simulations
Assembly: SpiceSharp.dll
Syntax
public abstract class BaseSimulation : Simulation
Remarks
Pretty much all simulations start out with calculating the operating point of the circuit. So a RealState is always part of the simulation.
Constructors
BaseSimulation(String)
Initializes a new instance of the BaseSimulation class.
Declaration
protected BaseSimulation(string name)
Parameters
| Type | Name | Description |
|---|---|---|
| System.String | name | The identifier of the simulation. |
Properties
AbsTol
Gets the (cached) absolute tolerance on values to check convergence.
Declaration
protected double AbsTol { get; }
Property Value
| Type | Description |
|---|---|
| System.Double |
BaseSimulationStatistics
Gets the (cached) simulation statistics for the simulation.
Declaration
protected BaseSimulationStatistics BaseSimulationStatistics { get; }
Property Value
| Type | Description |
|---|---|
| BaseSimulationStatistics |
DcMaxIterations
Gets the maximum number of allowed iterations for DC analysis.
Declaration
protected int DcMaxIterations { get; }
Property Value
| Type | Description |
|---|---|
| System.Int32 |
ProblemVariable
Gets the variable that causes issues.
Declaration
public Variable ProblemVariable { get; protected set; }
Property Value
| Type | Description |
|---|---|
| Variable |
Remarks
This variable can be used to close in on the problem in case of non-convergence.
RealState
Gets the currently active simulation state.
Declaration
public BaseSimulationState RealState { get; protected set; }
Property Value
| Type | Description |
|---|---|
| BaseSimulationState |
RelTol
Gets the (cached) relative tolerance on values to check convergence.
Declaration
protected double RelTol { get; }
Property Value
| Type | Description |
|---|---|
| System.Double |
Methods
Execute()
Executes the simulation.
Declaration
protected override void Execute()
Overrides
IsConvergent()
Checks that the solution converges to a solution.
Declaration
protected bool IsConvergent()
Returns
| Type | Description |
|---|---|
| System.Boolean |
|
Iterate(Int32)
Iterates towards a solution.
Declaration
protected bool Iterate(int maxIterations)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | maxIterations | The maximum allowed iterations. |
Returns
| Type | Description |
|---|---|
| System.Boolean |
|
IterateDiagonalGminStepping(Int32, Int32)
Iterates to a solution while adding a conductive path to ground on all nodes.
Declaration
protected bool IterateDiagonalGminStepping(int maxIterations, int steps)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | maxIterations | The maximum number of iterations per step. |
| System.Int32 | steps | The number of steps. |
Returns
| Type | Description |
|---|---|
| System.Boolean |
IterateGminStepping(Int32, Int32)
Iterates to a solution while shunting PN-junctions with a conductance.
Declaration
protected bool IterateGminStepping(int maxIterations, int steps)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | maxIterations | The maximum number of iterations per step. |
| System.Int32 | steps | The number of steps. |
Returns
| Type | Description |
|---|---|
| System.Boolean |
IterateSourceStepping(Int32, Int32)
Iterates to a solution slowly ramping up independent voltages and currents.
Declaration
protected bool IterateSourceStepping(int maxIterations, int steps)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | maxIterations | The maximum number of iterations per step. |
| System.Int32 | steps | The number of steps. |
Returns
| Type | Description |
|---|---|
| System.Boolean |
Load()
Load the current simulation state solver.
Declaration
protected void Load()
LoadBehaviors()
Loads the current simulation state solver.
Declaration
protected virtual void LoadBehaviors()
LoadNodeSets(Object, LoadStateEventArgs)
Applies nodesets.
Declaration
protected void LoadNodeSets(object sender, LoadStateEventArgs e)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Object | sender | Sender |
| LoadStateEventArgs | e | Arguments |
OnAfterLoad(LoadStateEventArgs)
Raises the AfterLoad event.
Declaration
protected virtual void OnAfterLoad(LoadStateEventArgs args)
Parameters
| Type | Name | Description |
|---|---|---|
| LoadStateEventArgs | args | The LoadStateEventArgs instance containing the event data. |
OnAfterTemperature(LoadStateEventArgs)
Raises the AfterTemperature event.
Declaration
protected virtual void OnAfterTemperature(LoadStateEventArgs args)
Parameters
| Type | Name | Description |
|---|---|---|
| LoadStateEventArgs | args | The LoadStateEventArgs instance containing the event data. |
OnBeforeLoad(LoadStateEventArgs)
Raises the BeforeLoad event.
Declaration
protected virtual void OnBeforeLoad(LoadStateEventArgs args)
Parameters
| Type | Name | Description |
|---|---|---|
| LoadStateEventArgs | args | The LoadStateEventArgs instance containing the event data. |
OnBeforeTemperature(LoadStateEventArgs)
Raises the BeforeTemperature event.
Declaration
protected virtual void OnBeforeTemperature(LoadStateEventArgs args)
Parameters
| Type | Name | Description |
|---|---|---|
| LoadStateEventArgs | args | The LoadStateEventArgs instance containing the event data. |
Op(Int32)
Calculates the operating point of the circuit.
Declaration
protected void Op(int maxIterations)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | maxIterations | The maximum amount of allowed iterations. |
Setup(EntityCollection)
Set up the simulation.
Declaration
protected override void Setup(EntityCollection circuit)
Parameters
| Type | Name | Description |
|---|---|---|
| EntityCollection | circuit | The circuit that will be used. |
Overrides
Temperature()
Perform temperature-dependent calculations.
Declaration
protected void Temperature()
Unsetup()
Destroys the simulation.
Declaration
protected override void Unsetup()
Overrides
Events
AfterLoad
Occurs after loading the matrix and right-hand side vector.
Declaration
public event EventHandler<LoadStateEventArgs> AfterLoad
Event Type
| Type | Description |
|---|---|
| System.EventHandler<LoadStateEventArgs> |
Remarks
For better performance, you can also create an entity with a low priority that generates a load behavior.
AfterTemperature
Occurs after performing temperature-dependent calculations.
Declaration
public event EventHandler<LoadStateEventArgs> AfterTemperature
Event Type
| Type | Description |
|---|---|
| System.EventHandler<LoadStateEventArgs> |
Remarks
For better performance, you can also create an entity with a low priority that creates a temperature behavior.
BeforeLoad
Occurs before loading the matrix and right-hand side vector.
Declaration
public event EventHandler<LoadStateEventArgs> BeforeLoad
Event Type
| Type | Description |
|---|---|
| System.EventHandler<LoadStateEventArgs> |
Remarks
For better performance, you can also create an entity with a high priority that generates a load behavior.
BeforeTemperature
Occurs before performing temperature-dependent calculations.
Declaration
public event EventHandler<LoadStateEventArgs> BeforeTemperature
Event Type
| Type | Description |
|---|---|
| System.EventHandler<LoadStateEventArgs> |
Remarks
For better performance, you can also create an entity with a high priority that creates a temperature behavior.


Skip counting means counting by numbers other than 1. Look at the number lines. Listen to your teacher skip count by 2s. Repeat after him or her.
Count by 2s. Write each missing number in the blank.


 It will be gone forever! (a really long time)
{% endblock tabcontent %} {% block jsfiles %} {% endblock jsfiles %}


HAPPY TEXAS (M). (Miramax/Palace) Director: Mark Illsley Stars: Jeremy Northam, Steve Zahn, William H Macy, Illeana Douglas, Ally Walker, Ron Perlman, M C Gainey, Tim Bagley, Michael Hitchcock, Paul Dooley Running time: 95 minutes.
Despite becoming more commercial over the years, the Sundance Film Festival still manages to showcase some of the best of American independent cinema and unearth a few new talented directors. Happy Texas was one of the surprise hits of the 1999 festival, and inspired a bidding war amongst some of the studios.
This delightfully off beat comedy is the first film from writer Ed Stone and director Mark Illsley, who crafted his skills as an assistant with Kevin Reynolds (Robin Hood: Prince Of Thieves, Rapa Nui, etc).
While the wonderfully named, barely literate car thief Wayne Wayne Wayne jr (Steve Zahn, from Out Of Sight, Bandwagon, etc) is left with eager teacher Ms Schaefer (Illeana Douglas) to help hone the talents of his young charges, the more suave Harry Sawyer (Jeremy Northam, largely cast against type) checks out the local bank, which he judges is ripe for the picking.
But Harry slowly falls in love with the beautiful bank manager (Profiler's Ally Walker), unaware that Chappy (William H Macy), the town's lonely and closeted sheriff, has also secretly fallen for him - hard. Further complications develop when another escaped convict shows up and forces Harry and Wayne to help him rob the bank.
Happy Texas follows on from those other recent comedies (In & Out, The Birdcage, Three To Tango, etc) that embrace complex issues of male sexuality and identity and milk the possibilities of the scenario for laughs. This charming and deftly written comedy also moves into more familiar territory when it takes a non-judgmental look at the mores and attitudes of small town America. This is a town that welcomes a pair of gay pageant directors with open arms because they are strangers passing through, but somehow forces the sheriff to conceal his sexuality because he has to live and work with these people. Happy Texas draws much of its genial humour from its look at life in this small town and its quirky inhabitants, although there is nothing malicious in it.
Unfortunately this zesty and fast paced film seems to run out of puff before the final reel. The film is let down slightly only by the somewhat conventional nature of its very busy finale, which includes a chase and a shoot-out. Illsley manages to strike a nice balance between the slapstick and the poignant here, and he directs with surprising restraint, given his limited experience.
The solid cast throw themselves into their roles with enthusiasm, but the film is lifted somewhat by two standout performances. The busy but always reliable Macy brings a nice touch of pathos to his wonderful performance as Chappy, the lovelorn sheriff. Zahn is superb and brings a nice manic energy and physical quality to his boisterous role.
During the hectic film going holiday season you should make a detour via the multiplexes to check out Happy Texas. It will put a smile on your face.
***1/2 greg king http://www.netau.com.au/gregking
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


This is the final project for computer programming.
Reation Time Test
Current Version: 1.0.1-r
Netlify hosting master branch html:
See myrecords for my best times!
My to-do list:
See my github:


Photography, Graphics, Colors
by
Photography, Colors, Illumination
Photography, City, Natural
Studio, Blog, Ideas
Paint, Red, Colors, Acrylic
Photography, People, Red, Unity
Paint, Photography, Colors
Illustration, Art, Modernism
Fantasy, Graphics, Curiousity
Plant, Light, Life, Photography
Moonlight, Painting, Horizon
Photography, Ships, Horizon, Sea
Illustration, Architecture
Illustration, Humanistic, Eye


Constructor
new Reference(translationnullable, bookName, chapterNo, verseNo)
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
translation |
Translation |
<nullable> |
The referenced bible translation |
bookName |
BookName | The name of the bible book |
|
chapterNo |
number | The number of the chapter (one-based) |
|
verseNo |
number | The number of the verse (one-based) |
Extends
Members
bookName
Properties:
| Name | Type | Description |
|---|---|---|
bookName |
BookName | The bible book this reference is pointing at |
chapterNo
Properties:
| Name | Type | Description |
|---|---|---|
chapterNo |
number | The number of the chapter (one-based) |
- Inherited From:
- Source:
translation
Properties:
| Name | Type | Attributes | Description |
|---|---|---|---|
translation |
Translation |
<nullable> |
The bible translation the reference is pointing at |
verseNo
Properties:
| Name | Type | Attributes | Description |
|---|---|---|---|
verseNo |
number |
<nullable> |
The number of the verse (one-based), or null if he whole chapter is referenced |
- Inherited From:
- Source:
Methods
format(library, opt) → {string}
Format the reference.
Parameters:
| Name | Type | Description |
|---|---|---|
library |
Library | The library to use for loading format resources |
opt |
FormatOptions | An object with formatting options |
- Overrides:
- Source:
Returns:
The formatted reference
- Type
- string
isChapterMatch(chapterNo) → {boolean}
Checks whether the chapterNo matches the reference.
Parameters:
| Name | Type | Description |
|---|---|---|
chapterNo |
number | The number of the chapter in question |
- Inherited From:
- Source:
Returns:
true if this reference is pointing at the given chapter; otherwise false
- Type
- boolean
isVerseMatch(chapterNo, verseNo) → {boolean}
Checks whether the given chapterNo and verseNo matches the verse location.
Parameters:
| Name | Type | Description |
|---|---|---|
chapterNo |
number | The number of the chapter in question |
verseNo |
number | The number of the verse in question |
- Inherited From:
- Source:
Returns:
true if the given chapterNo and verseNo matches the location; otherwise false
- Type
- boolean
multiChapter() → {boolean}
Checks whether the reference spans over more than one chapter
Returns:
true if the reference spans more than one chapter; otherwise false
- Type
- boolean
toString() → {string}
- Overrides:
- Source:
Returns:
A text representation of the reference
- Type
- string


Let's make some shapes! JanusVR has several built-in shapes that you can use to build your world. Let's add one of each to the world we created in the first step, and lay them out in a circle.  With math, of course! We want to organize everything in a circle around the center of the room, with a nice comfortable 3m radius.
A circle is 360 degrees, aka 2*PI radians, and we have 9 objects to place in a circle. So by dividing the size of the circle by the number of items, we find that we should place the item every 40 degrees, or 0.7 radians.
We can then use some basic trigonometry to turn those into (x,y,z) coordinates for each item:
var numItems = 9, radius = 3, stepSize = 2 * Math.PI / numItems; for (var i = 0; i < numItems; i++) { var x = Math.sin(i * stepSize) * radius, y = 1, z = Math.cos(i * stepSize) * radius; console.log(i, x.toFixed(1) + ' ' + y + ' ' + z.toFixed(1)) }


% include('../widget/top',{ title: '滴滴校园平台', locals: local, css: ['/static_proxy/themes/blue/books/front.css','/static_proxy/themes/blue/books/screen.css','/static_proxy/themes/blue/books/homepage.css'] }); %>
<% include('../widget/bottom', { locals: local }); %>


Mood Ring
Home
Form
History
Contact
Mood Form
Name
How many hours of sleep did you get yesterday?
What did you eat yesterday?
Did you exercise yesterday?
---
Yes
No
Supplements
Medications
What is your mood like?
---
Excellent
Very good
Good
---
Not so bad
Bad
Terrible
Submit