logger.info("{}: {}", key)
where the number of {}
placeholders
in the logger message doesn't match the number of other arguments to the logging call.
Use the inspection option to specify which implementation SLF4J uses.
If Check automatically is chosen, then org.apache.logging.slf4j.Log4jLogger
is searched in the classpath.
If this file is founded or Yes is chosen, then cases, when the last parameter with an exception type has a placeholder, will
not be reported for SLFJ4 API.
For example:
// will not be reported
log.error("For id {}: {}", id, new RuntimeException());
This option works only for SLF4J.


{{>includes/header}}
Bankruptcy registration
1. Input official details
2. Input debtor details
3. Check and verify details
4. Key number
Court
Key number
Return to this application later
Page 1 of 2
Next
Page 1 of 2
Next
Page 2 of 2
Previous
Page 2 of 2
Previous
{{>includes/footer}}


I have no fight with Khune — Akpeyi
by Bowale OdutolaDaniel Akpeyi does not see a fight materialising between himself and Itumeleng Khune for Kaizer Chiefs’ goalkeeping jersey‚ but rather a healthy rivalry and competition.
Khune has recently returned from injury to full training‚ though Amakhosi coach Ernst Middendorp said the Bafana Bafana keeper has a way to go to be “match fit”.
He believed Akpeyi has commanded the posts in Khune’s prolonged absence‚ and won over Chiefs’ fans‚ that the Nigeria international was awarded the Absa Premiership’s Player of the Month prize for September/October on Thursday.
“On Khune‚ I don’t think we are having any fight on who is going to be the No 1 or not‚” Akpeyi said.
“It’s only an opportunity that I’m having‚ having the coach to have confidence in me while Khune is injured.
“If Khune is fine and the coach decides on whoever he wants to play‚ we are cool.
“The good thing is that we have healthy competition in that department and everybody is pushing each other.
“One thing I like about Khune is that he supports you‚ from what I can see. He’s not actually looking at Daniel being No 2‚ or No 1‚ or something.
“It’s about being given the opportunity‚ and we support each other from there.”
Akpeyi kept another clean sheet for Chiefs – Amakhosi have not conceded in six of their last seven league games‚ and that was also a run of seven straight PSL victories – as the Soweto giants thrashed Stellenbosch FC 4-0 at Cape Town Stadium on Wednesday night.
Previous Post
Hours at Arsenal before Emery was sacked
Next Post
Akpeyi wins Player of the Month award


predict_classes-ConsensusPartition-method.Rd
Predict classes for new samples based on cola classification
# S4 method for ConsensusPartition predict_classes(object, k, mat, silhouette_cutoff = 0.5, fdr_cutoff = cola_opt$fdr_cutoff, group_diff = cola_opt$group_diff, scale_rows = object@scale_rows, diff_method = "Ftest", dist_method = c("euclidean", "correlation", "cosine"), nperm = 1000, p_cutoff = 0.05, plot = TRUE, col_fun = NULL, split_by_sigatures = FALSE, force = FALSE, verbose = TRUE, help = TRUE, prefix = "", mc.cores = 1, cores = mc.cores)
| object | A |
|---|---|
| k | Number of subgroups to get the classifications. |
| mat | The new matrix where the sample classes are going to be predicted. The number of rows should be the same as the original matrix for cola analysis (also make sure the row orders are the same). Be careful that the scaling of |
| silhouette_cutoff | Send to |
| fdr_cutoff | Send to |
| group_diff | Send to |
| scale_rows | Send to |
| diff_method | Send to |
| dist_method | Distance method. Value should be "euclidean", "correlation" or "cosine". Send to |
| nperm | Number of permutatinos. It is used when |
| p_cutoff | Cutoff for the p-values for determining class assignment. Send to |
| plot | Whether to draw the plot that visualizes the process of prediction. Send to |
| col_fun | A color mapping function generated from |
| split_by_sigatures | Should the heatmaps be split based on k-means on the main heatmap, or on the patterns of the signature heatmap. |
| force | If the value is |
| verbose | Whether to print messages. Send to |
| help | Whether to print help messages. |
| prefix | Used internally. |
| mc.cores | Number of cores. This argument will be removed in future versions. |
| cores | Number of cores, or a |
The prediction is based on the signature centroid matrix from cola classification. The processes are as follows:
1. For the provided ConsensusPartition-class
object and a selected k, the signatures that discriminate classes
are extracted by get_signatures,ConsensusPartition-method
. If number of signatures is more than 2000, only 2000 signatures are randomly sampled.
2. The signature centroid matrix is a k-column matrix where each column is the centroid of samples in the corresponding
class, i.e. the mean across samples. If rows were scaled in cola analysis, the signature centroid matrix is the mean of scaled
values and vise versa. Please note the samples with silhouette score less than silhouette_cutoff
are removed
for calculating the centroids.
3. With the signature centroid matrix and the new matrix, it calls predict_classes,matrix-method
to perform the prediction.
Please see more details of the prediction on that help page. Please note, the scales of the new matrix should be the same as the matrix
used for cola analysis.
A data frame with two columns: the class labels (in numeric) and the corresponding p-values.
predict_classes,matrix-method
that predicts the classes for new samples.
# \donttest{ data(golub_cola) res = golub_cola["ATC:skmeans"] mat = get_matrix(res) # note scaling should be applied here because the matrix was scaled in the cola analysis mat2 = t(scale(t(mat))) cl = predict_classes(res, k = 3, mat2)#> The matrix has been scaled in cola analysis, thus the new matrix should #> also be scaled with the same method ('z-score'). Please double check. #> Set `help = FALSE` to suppress this message. #> #> * take top 500/500 most significant signatures for prediction.# compare the real classification and the predicted classification data.frame(cola_class = get_classes(res, k = 3)[, "class"], predicted = cl[, "class"])#> cola_class predicted #> 1 3 3 #> 2 3 3 #> 3 2 2 #> 4 2 2 #> 5 2 2 #> 6 3 3 #> 7 2 2 #> 8 2 2 #> 9 2 2 #> 10 2 2 #> 11 2 2 #> 12 2 2 #> 13 2 2 #> 14 2 2 #> 15 2 2 #> 16 2 2 #> 17 2 2 #> 18 3 3 #> 19 3 3 #> 20 2 2 #> 21 1 1 #> 22 1 1 #> 23 1 1 #> 24 1 1 #> 25 2 2 #> 26 1 1 #> 27 1 1 #> 28 2 2 #> 29 1 1 #> 30 1 1 #> 31 2 2 #> 32 1 1 #> 33 1 1 #> 34 1 1 #> 35 3 3 #> 36 2 2 #> 37 3 3 #> 38 3 3 #> 39 2 2 #> 40 3 3 #> 41 3 3 #> 42 3 3 #> 43 2 2 #> 44 2 2 #> 45 2 2 #> 46 1 1 #> 47 2 2 #> 48 2 2 #> 49 2 2 #> 50 2 2 #> 51 2 2 #> 52 3 3 #> 53 2 2 #> 54 2 2 #> 55 2 2 #> 56 1 1 #> 57 3 3 #> 58 2 2 #> 59 1 1 #> 60 2 2 #> 61 3 3 #> 62 1 1 #> 63 1 1 #> 64 1 1 #> 65 1 1 #> 66 1 1 #> 67 1 1 #> 68 2 2 #> 69 1 1 #> 70 1 1 #> 71 1 1 #> 72 1 1#> The matrix has been scaled in cola analysis, thus the new matrix should #> also be scaled with the same method ('z-score').


{% extends "_base.html" %} {% block title %}Signed Out{% endblock %} {% block main %}
You have been signed out.


Congratulations! You have created your first AWS Lambda project. So what's next?
Open up PentahoSyncReportHandler.java and implement the handleRequest method. This method is the entry point for your Lambda function, and it will be invoked by Lambda in response to input from the event sources of your function.
Note: You can add new classes and additional external dependencies in your project if needed.
Open up PentahoSyncReportHandlerTest.java. Fill in your test logic to validate the input and output of your function handler, and then run it locally as a normal JUnit test.
Note: The unit test provides a sample JSON input file if you have chosen a predefined event type as your function input. You can modify the JSON file, or create new ones based on it.
Under Project or Package Explorer View, right-click on your project and select Amazon Web Services -> Upload Function to AWS Lambda. Then follow the steps to create a new Lambda function or upload your code to an existing function.
Now we are ready to run the function in the cloud. Right-click on your project again and select Amazon Web Services -> Run on AWS Lambda.
In the input dialog, enter the JSON input for your function, or select one of the JSON files in your project.
Tip: You can add new JSON input files in your project, and they will show up in this dialog as long as the file name ends with ".json".
Click Invoke and check the output of your function in the Eclipse Console View.
If you want to know more about AWS Lambda, check out the following links:
Contact us to send bug reports and feedbacks.
AWS SDK for Java team


Hoard Overlay Unity
Boilerplate for account management
Class Hierarchy
Go to the textual class hierarchy
Generated by
1.8.17


Learning in latent variable models
Up to now, we have assumed that when learning a directed or an undirected model, we are given examples of every single variable that we are trying to model.
However, that may not always be the case. Consider for example a probabilistic language model of news articlesA language model assigns probabilities to sequences of words . We can, among other things, sample from to generate various kinds of sentences. . Each article typically focuses on a specific topic , e.g. finance, sports, politics. Using this prior knowledge, we may build a more accurate model , in which we have introduced an additional, unobserved variable . This model can be more accurate, because we can now learn a separate for each topic, rather than trying to model everything with one .
However, since is unobserved, we cannot directly use the learning methods that we have so far. In fact, the unobserved variables make learning much more difficult; in this chapter, we will look at how to use and how to learn models that involve latent variables.
Latent variable models
More formally, a latent variable model (LVM) is a probability distribution over two sets of variables :
where the variables are observed at learning time in a dataset and the are never observed.
The model may be either directed or undirected. There exist both discriminative and generative LVMs, although here we will focus on the latter (the key ideas hold for discriminative models as well).
Example: Gaussian mixture models
Gaussian mixture models (GMMs) are a latent variable model that is also one of the most widely used models in machine learning.
Example of a dataset that is best fit with a mixture of two Gaussians. Mixture models allow us to model clusters in the dataset.
In a GMM, each data point is a tuple with and ( is discrete). The joint is a directed model
where for some vector of class probabilities and
is a multivariate Gaussian with mean and variance .
This model postulates that our observed data is comprised of clusters with proportions specified by ; the distribution within each cluster is a Gaussian. We can see that is a mixture by explicitly writing out this probability:
To generate a new data point, we sample a cluster and then sample its Gaussian .
Why are latent variable models useful?
There are two reasons why we might want to use latent variable models.
The simplest reason is that some data might be naturally unobserved. For example, if we are modeling a clinical trial, then some patients may drop out, and we won’t have their measurements. The methods in this chapter can be used to learn with this kind of missing data.
However, the most important reason for studying LVMs is that they enable us to leverage our prior knowledge when defining a model. Our topic modeling example from the introduction illustrates this. We know that our set of news articles is actually a mixture of distinct distributions (one for each topic); LVMs allow us to design a model that captures this.
LVMs can also be viewed as increasing the expressive power of our model. In the case of GMMs, the distribution that we can model using a mixture of Gaussian components is much more expressive than what we could have modeled using a single component.
Marginal likelihood training
How do we train an LVM? Our goal is still to fit the marginal distribution over the visible variables to that observed in our dataset . Hence our previous discussion about KL divergences applies here as well and by the same argument, we should be maximizing the marginal log-likelihood of the data
This optimization objective is considerably more difficult than regular log-likelihood, even for directed graphical models. For one, we can see that the summation inside the log makes it impossible to decompose into a sum of log-factors. Hence, even if the model is directed, we can no longer derive a simple closed form expression for the parameters.
Exponential family distributions (gray lines) have concave log-likelihoods. However, a weighted mixture of such distributions is no longer concave (black line).
Looking closer at the distribution of a data point , we also see that it is actually a mixture
of distributions with weights . Whereas a single exponential family distribution has a concave log-likelihood (as we have seen in our discussion of undirected models), the log of a weighted mixture of such distributions is no longer concave or convex.
This non-convexity requires the development of specialized learning algorithms.
Learning latent variable models
Since the objective is non-convex, we will resort to approximate learning algorithms. These methods are widely used in practice and are quite effectiveNote however, that (quite surprisingly), many latent variable models (like GMMs) admit algorithms that can compute the global optimum of the maximum likelihood objective, even though it is not convex. Such methods are covered at the end of CS229T. .
The Expectation-Maximization algorithm
The Expectation-Maximization (EM) algorithm is a hugely important and widely used algorithm for learning directed latent-variable graphical models with parameters and latent .
The EM algorithm relies on two simple observations.
- If the latent were fully observed, then we could optimize the log-likelihood exactly using our previously seen closed form solution for .
- Knowing the weights, we can often efficiently compute the posterior (this is an assumption; it is not true for some models).
EM follows a simple iterative two-step strategy: given an estimate of the weights, compute and use it to “hallucinate” values for . Then, find a new by optimizing the resulting tractable objective. This process will eventually converge.
We haven’t exactly defined what we mean by “hallucinating” the data. The full definition is a bit technical, but its instantiation is very intuitive in most models like GMMs.
By “hallucinating” the data, we mean computing the expected log-likelihood
This expectation is what gives the EM algorithm half of its name. If is not too high-dimensional (e.g. in GMMs it is a one-dimensional categorical variable), then we can compute this expectation.
Since the summation is now outside the log, we can maximize the expected log-likelihood. In particular, when is a directed model, again decomposes into a sum of log-CPD terms that can be optimized independently, as discussed in the chapter on directed graphical models.
We can formally define the EM algorithm as follows. Let be our dataset.
- Starting at an initial , repeat until convergence for :
- E-Step: For each , compute the posterior .
- M-Step: Compute new weights via
Example: Gaussian mixture models
Let’s look at this algorithm in the context of GMMs. Suppose we have a dataset . In the E-step, we may compute the posterior for each data point as follows:
Note that each is simply the probability that originates from component given the current set of parameters . After normalization, these form the -dimensional vector of probabilities .
Recall that in the original model, is an indicator variable that chooses a component for ; we may view this as a “hard” assignment of to one component. The result of the step is a -dimensional vector (whose components sum to one) that specifies a “soft” assignment to components. In that sense, we have “hallucinated” a “soft” instantiation of ; this is what we meant earlier by an “intuitive interpretation” for .
At the M-step, we optimize the expected log-likelihood of our model.
We can optimize each of these terms separately. We will start with . We have to find that maximize
where is a constant that does not depend on and is a probability distribution defined over as
Now we know that is optimized when equals (as discussed in the section on learning directed models, this objective equals the KL divergence between and , plus a constant). Moreover, since is in the exponential family, it is entirely described by its sufficient statistics (recall our discussion of exponential families in the section on learning undirected models). Thus, we may set the mean and variance to those of , which are
and
Note how these are the just the mean and variance of the data, weighted by their cluster affinities! Similarly, we may find out that the class priors are
Although we have derived these results using general facts about exponential families, it’s equally possible to derive them using standard calculus techniques.
EM as variational inference
Why exactly does EM converge? We can understand the behavior of EM by casting it in the framework of variational inference.
Consider the posterior inference problem for , where the variables are held fixed as evidence. We may apply our variational inference framework by taking to be the unnormalized distribution; in that case, will be the normalization constant.
Recall that variational inference maximizes the evidence lower bound (ELBO)
over distributions . The ELBO satisfies the equation
Hence, is maximized when ; in that case the KL term becomes zero and the lower bound is tight:
The EM algorithm can be seen as iteratively optimizing the ELBO over (at the E step) and over (at the M) step.
Starting at some , we compute the posterior at the step. We evaluate the ELBO for ; this makes the ELBO tight:
Next, we optimize the ELBO over , holding fixed. We solve the problem
Note that this is precisely the optimization problem solved at the step of EM (in the above equation, there is an additive constant independent of ).
Solving this problem increases the ELBO. However, since we fixed to , the ELBO evaluated at the new is no longer tight. But since the ELBO was equal to before optimization, we know that the true log-likelihood must have increased.
We now repeat this procedure, computing (the E-step), plugging into the ELBO (which makes the ELBO tight), and maximizing the resulting expression over . Every step increases the marginal likelihood , which is what we wanted to show.
Properties of EM
From our above discussion, it follows that EM has the following properties:
- The marginal likelihood increases after each EM cycle.
- Since the marginal likelihood is upper-bounded by its true global maximum, and it increases at every step, EM must eventually converge.
However, since we optimizing a non-convex objective, we have no guarantee to find the global optimum. In fact, EM in practice converges almost always to a local optimum, and moreover, that optimum heavily depends on the choice of initialization. Different initial can lead to very different solutions, and so it is very common to use multiple restarts of the algorithm and choose the best one in the end. In fact EM is so sensitive to the choice of initial parameters, that techniques for choosing these parameters are still an active area of research.
In summary, the EM algorithm is a very popular technique for optimizing latent variable models that is also often very effective. Its main downside are its difficulties with local minima.
| Index | Previous | Next |


{% extends "lifeflow/editor/base.html" %} {% block body %}
{{ comment.name }} ({{ comment.email }}) at {{ comment.date }} on {{ comment.entry }}.
{{ comment.html|safe }}
{% for comment in page.object_list.all %}-
delete
{% endfor %}
{{ comment.name }} ({{ comment.email }}) at {{ comment.date }} on {{ comment.entry }}.
{{ comment.html|safe }}


{%extends "base/page.html"%} {%load markup%} {%block title%}{{obj.title}}{%endblock%} {%block contents%}
This post has been migrated from a previous version of the PostgreSQL website. We apologise for any formatting issues caused by the migration.
{%endif%} {%endblock%}


Apache Ignite was always appreciated by its users for two primary things it delivers - scalability and performance. Throughout the lifetime many distributed systems tend to do performance optimizations from a release to release while making scalability related improvements just a couple of times. It's not because the scalability is of no interest. Usually, scalability requirements are set and solved once by a distributed system and don't require significant additional interventions by engineers.
However, Apache Ignite grew to the point when the community decided to revisit its discovery subsystem that influences how well and far Ignite scales out. The goal was pretty clear - Ignite has to scale to 1000s of nodes as good as it scales to 100s now.
It took many months to get the task implemented. So, please join me in welcoming Apache Ignite 2.5 that now can be scaled easily to 1000s of nodes and goes with other exciting capabilities. Let's check out the most prominent ones.
Massive Scalability
There are two components of Ignite that were modified in Ignite 2.5 to improve its scalability capabilities. The first one is related to 1000s nodes clusters while the other is related to the way we train machine learning (ML) models in Ignite. Let's start with the first.Marrying Apache Ignite and ZooKeeper
Right, that 1000s nodes scalability goal was solved with the help of Apache ZooKeeper. Why did we turn to it?
Apache Ignite default TCP/IP Discovery organizes cluster nodes into a ring-topology form that has its advantages and disadvantages. For instance, on topologies with hundreds of cluster nodes, it can take many seconds why a system message traverse through all the nodes. As a result, necessary processing of events such as joining of new nodes or detecting of failed ones can take a while affecting overall cluster responsiveness and performance. That is a big deal if you'd like to run 1000s nodes clusters.
The new ZooKeeper Discovery uses ZooKeeper as a single point of synchronization where Ignite nodes are exchanging discovery events through it. It solved the issue with long-to-be-processed discovery messages and, as a result, allowed Ignite scaling to large cluster topologies.
As a rule of thumb, keep using default TCP/IP Discovery if it's unlikely that your Ignite cluster scales beyond 300s nodes and switch to ZooKeeper Discovery if that's the case.
Machine Learning: Partition-Based Datasets
That's the second prominent feature of Ignite 2.5 that improves the way of how far you can scale your Ignite clusters to train ML models over terabytes or petabytes of data. The partition-based datasets moved us closer to the implementation of Zero-ETL concept which implies that Ignite can be used as a single storage where ML models and algorithms are being improved iteratively and online without ETLing data back and forth between Ignite and another storage.
Read more about the datasets from this documentation page.
Genetic Algorithms
Ignite's ML component is ramping up and in the version 2.5 it accepted a contribution of genetic algorithms (GAs) which help to solve optimization problems by simulating the process of biological evolution. GAs are excellent for searching through large and complex data sets for an optimal solution. Real world applications of GAs include automotive design, computer gaming, robotics, investments, traffic/shipment routing and more.Refer to excessive articles of my community-mates Turik Campbell and Akmal B. Chaudhri which cover main benefits of GAs:
Continuous Self-Healing and Consistency Checks
It's a known fact that many companies and businesses trusted Ignite its mission-critical deployments and solutions. As a result, sometimes Ignite doesn't even have a right to "misfire" and should be able to handle critical or unpredictable situations automatically or provide facilities to do deal with them manually.With Ignite 2.5, we've kicked off the realization of continuous self-healing concept that implies that no matter what happens with Ignite in production it should be able to tolerate unexpected failures and stay up and running. The following was done in 2.5:
- Critical Failures Handling
- Long running transactions monitoring and termination
- Data Consistency Check Facilities
SQL: Security and Fast Data Loading
The community stays strong and determined in its goal of making Ignite SQL engine undistinguishable from SQL engines of famous and mature SQL database. What's the purpose? We want to make it easy for you to migrate from a relational database to Ignite, so that you can reuse all your skills gained before. Overall, this is what our SQL engine got in 2.5:
- Fast data loading with COPY command and streaming mode using SQL APIs.
- Long running transactions monitoring and termination
- Secured Ignite cluster. Use CREATE USER, DROP USER and ALTER USER commands to manage who is allowed to connect to your clusters.
In-place Execution of Spark DataFrame Queries
Apache Spark users can applaud because the following ticket got merged in 2.5. In short, it means that from now on Ignite will be able to execute as many DataFrames SQL queries as it can in-place on Ignite servers side avoiding data movement from Ignite to Spark. The performance of your DataFrames queries should boost significantly. Enjoy!
DEB and RPM packages
Last but not least, if you're a Linux user, now you can install the latest Ignite versions directly from DEB and RPM repositories. Refer to how-to and share your feedback with us.
Finally, I have no more paper left to cover other optimizations and improvements. So, go ahead and check out our release notes.


Do you find yourself arguing with your friends about famous dead people? Well, stop arguing about weird things in public, and find out definitively who knows the most about those whom are no more, have ceased to be, and/or are bereft of life.
With this quick quiz, you can discover, beyond the shadow of a doubt, who among you has learned the most about the bereft of life, the resting in peace, those whom have kicked the bucket, shuffled off this mortal coil, and run down the curtain to join the choir invisible. In other words, ex-people.


Welcome to CVXMG 2.0.0¶
CVXMG is a python based package that allows the users to compute the sizing of Isolated/Islanded MicroGrids (IMGs). Additionally to the sizing of the IMGs, CVXMG returns the optimal dispatch of the energy sources and the optimal tariffs for the energy. CVXMG allows implementing Demand Side Management (DSM) in the sizing of the IMGs. Four different DSM strategies based on dynamic pricing of the energy can be easily choose for the user. Time of Use, Critical Peak Pricing, Day-Ahead Dynamic Pricing, and a DSM based on economic incentives. This characteristic allows CVXMG to provide the optimal tariffs for the energy sold to the customers in the IMG. Additionally, CVXMG can use a DSM based on curtailment of the electric loads. The implementation of DSM in the sizing of IMGs makes CVXMG a worth looking tool for different analyses for IMG planners and policymakers.
CVXMG uses CVXPY at its core. CVXPY is a Python-embedded modeling language for convex optimization problems. CVXPY allows CVXMG to build and solve deterministic and stochastic convex formulations to perform the analysis of the IMGs. Due to the speed of solution of convex formulations, CVXMG can perform a multiyear analysis in seconds! Moreover, CVXMG can execute multiyear stochastic analysis in a regular machine.
Installing CVXMG¶
CVXMG can be easily installed using PyPi or downloading the GitHub repository. To install CVXMG just execute the following in your line of commands:
pip install cvxmg
Using CVXMG¶
CVXMG uses two simple dictionaries “prob_info” and “sources_info” to create different architectures of IMGs. These two dictionaries are passed as attributes for the constructor classes. CVXMG offers three different constructor classes: One for deterministic analysis, one for multiyear analysis, and one for multiyear stochastic analysis. Each one of the constructors uses the information of “prob_info” to know the architecture of the IMG and the data of “sources_info” to know the characteristics of the energy sources. CVXMG creates the energy sources of the IMG as objects using the Objected Oriented Programming capabilities offered by Phyton. The use of objects for the energy sources allows CVXMG to build the optimization formulation of the problem using a Plug and Play approach.
Once the user defines “prob_info” and “sources_info” needs to execute a constructor. For more info on how to set “prob_info” and “sources_info”, please refer to the example section. If the user wants to compute the sizing of an IMG using a deterministic analysis of one year, the following command must be executed:
import cvxmg as cm
MicroGrid = cm.DeterministicDSMS(prob_info, sources_info)
The above line of commands will create the structure of the IMG in the object MicroGrid. Additionally, it will create all the optimization formulation following the rules of the Disciplined Convex Programming of CVXPY. However, at this moment, CVXMG did not solve the formulation yet. To solve the formulation, the user needs to execute the solve method:
MicroGrid.solveMG()
The above commands will solve the formulation and will store the results in the MicroGrid object. To extract the results, the user must execute:
summary, dispatch_results = MicroGrid.resultsMG()
The above line of commands will create a pandas structure in the variable summary with the essential variables of the sizing results. Additionally, the method will create another pandas structure to store the dispatch results of energy sources.
Finally, if the user wants to create some predetermined plots of the results can call the method plotMG:
MicroGrid.plotMG()


| Checks to see if two images have collided. |
| image1 = first image to test x1 = image1's x location y1 = image1's y location frame1 = image1's frame to test (optional) image2 = second image to test x2 = image2's x location y2 = image2's y location frame2 = image2's frame to text (optional) |
Command Description:
| This is THE command to get pixel-perfect collisions between images. It will not consider transparent pixels during the collision check (basically, only the 'meat' of the image will invoke a collision). This makes it perfect for most situations where you have odd-shaped graphics to text against. The ImagesOverlap command is MUCH faster, however, but can only determine if ANY of the two images have overlapped (this INCLUDES transparent pixels). This method works if you have graphics that completely fill their container and/or you don't plan on needing pinpoint accuracy. As with any collision detection system in Blitz, you will need to know the variable names of the two images, and their X and Y locations at the moment collision checking occurs. The example blatently uses graphics that are much smaller than their container to show you how accurate this command really is. The ImagesOverlap example is identical to this one - and shows how inaccurate the overlapping method can be with graphics of this nature. |
Example:
| ; ImagesCollide Example ; Turn on graphics mode Graphics 640,480,16 ; Create two new empty graphics to store our circle and box in gfxBox=CreateImage(50,50) gfxCircle=CreateImage(50,50) ; Draw the box image first ; Set drawing operations to point to our new empty graphic SetBuffer ImageBuffer(gfxBox) ; Change drawing color to blue Color 0,0,255 ;Draw our box (note that it has a 10 pixel space around it) Rect 10,10,30,30,1 ; Repeat for the circle graphic SetBuffer ImageBuffer(gfxCircle) Color 255,0,0 ; Note the extra space between the circle and the edge of the graphic Oval 10,10,30,30,1 ; Let's not forget to put the drawing buffer back! SetBuffer BackBuffer() ; Locate our box to a random, visible screen location boxX=Rnd(50,610) boxY=Rnd(50,430) ; Repeat the loop until we've had a collision Repeat ; Attach our mouse to the circle to move it circleX=MouseX() circleY=MouseY() ; Standard double buffer technique; clear screen first Cls ; Draw our objects at the designated location DrawImage gfxBox,boxX,boxY DrawImage gfxCircle,circleX,circleY ; Standard double buffer technique; flip after all drawing is done Flip ; We test the locations of our box and circle to see if they have pixel collided Until ImagesCollide (gfxBox,boxX,boxY,0,gfxCircle,circleX,circleY,0) ; Loop is over, we must've collided! Text 0,0, "WE'VE HAD A COLLISION! PRESS A MOUSE BUTTON" ; Can't see the text until we flip .. Flip ; Wait for a mouse click WaitMouse() ; End our graphics mode EndGraphics |


--- layout: default title: Work subtitle: Consultancy, software architecture & development tags: [PHP, work, projects, skills] permalink: /work.html ---
I am Co-Founder and CEO of the MPOWR IT GmbH in Dresden, Saxony, Germany
We operate as a professional IT consultancy, system architecture & software development
company in Germany and worldwide.
I am a co-founder and chairman of the local PHP user group in Dresden, Saxony, Germany
A PHP7+ micro-framework with components to develop web-based CQRS applications or APIs.
A simple website providing a code of conduct in several languages for the communities and events in and around the city of Dresden, Germany.
A PHP fast CGI client library for sending requests (a)synchronously to PHP-FPM
Validating data with a fluent interfaced class
A PHP OOP implementation of the "Kölner Phonetik Index" - a soundex-like algorithm for german language.
This is an adaption of Andy Theiler's precedural implementation with some fixes and unit tests.
A PHP7+ OOP implementation for validating crontab interval strings.
[triː <'em> daʊn]
& TreeMDown Multi
A single page PHP application for browsing markdown documents in a file structure and translating them to HTML.


A CSV file with at least 6 columns separated with a semicolon (;) :
- id : an unique identifier of the employee
- type : active or retired
- sex : male or female
- familyStatus : married, or not married
- age : age of employee
- group (optional) : a sub-population. ex : group of employees recruted before 2002, group of directors,...
Example :
id;type;sex;familyStatus;age;group
id1;active;male;married;28;3
id2;active;male;married;33;3
id3;active;female;not married;26;4
id4;active;female;not married;22;4
id5;active;male;married;26;3
id6;active;male;married;21;3
id7;active;male;married;20;3
id8;active;male;married;31;3
id9;active;female;not married;26;4
id10;active;male;not married;43;1


Movie Search
Welcome to Movie search
search
Search bar
Movie Name
Year
Search
Recent Search
Rating:
Genre:
Year:
Related Movies


Christoper Frank- going to Cecil College, Maryland
* Role: Graphic Designer, Presentation Consultant
Liam Miller- going to North Hunterdon High School
* Role: Graphic Designer, Presentation Consultant
Zack Hartman-Senior at Souderton Area High School
* Role: Application Creation & UI Design
Cole Roinson- Junior at Marple Newtown High School
* Role: Website Programmer
c h e c k o u t o u r f a c e b o o k p a g e


Check out my services below or read more about me by clicking the CV button.
What I offer Download my CV!I can make you a great design for your next web project!
I love making websites and apps. Let me create your next project!
I can create a wide variation of graphic designs, such as posters, menus and business cards!
Need help with something technical? I'll do my best to help you!


This data set is an example of the format required for creating a table for
ingestion to the (hab_groupR
) and (hab_tablR
)
functions. Values in this dataset determine which species are summarised and
what values constitute differing levels of management action.
mngt_response_triggers
a data.frame with 5 variables:
numeric index of the desired order of reportable groups
character representing the reportable group name as it is intended for the output
character representing the exact species name/s that compromise the reportable group
numeric values below this are categorised as surveillance
numeric values equal to or above are categorised as notification
Although this is an example of the current triggers (as at time of writing) it is intended that this be used as a template to guide the creation of trigger data that would be saved out as a csv for use with the HAB functions. Note that values falling between surveillance and notification are classified as investigate.
mngt_response_triggers#> # A tibble: 12 x 5 #> table_ord table_name spp_name surveillance notification #> <dbl> <chr> <chr> <dbl> <dbl> #> 1 1 Alex spp alexandrium_spp 5 10 #> 2 2 Dino spp dinophysis_acuminata 23 230 #> 3 2 Dino spp dinophysis_caudata 23 230 #> 4 2 Dino spp dinophysis_acuta 23 230 #> 5 2 Dino spp dinophysis_fortii 23 230 #> 6 3 karenia spp karenia_spp 50 500 #> 7 4 karlo spp karlodinium_spp 10000 30000 #> 8 5 Pn seriata group pseudonitzschia_seria~ 10 100 #> 9 6 Pn delicatissima ~ pseudonitzschia_delic~ 100 500 #> 10 6 Pn delicatissima ~ pseudonitzschia_spp 100 500 #> 11 7 H akashiwo heterosigma_akashiwo 20000 40000 #> 12 8 F japonica fibrocapsa_japonica 20000 40000


submergence genes expression maize tolerant MoW tolerance using response sensitive submergence. Arabidopsis Plant data gene lines analysis senescence CBF higher levels rice expressed genotypes leaf significant *** compared showed transcription ERF additional submerged Click LINK WRKY control file. inbreds < plants factor lower relative {border-style differences Fig. QTL ROS Subtol Table differentially px;} #ffffff;} (PDF) Fig significantly used comparisons induction responses transcript .). associated enrichment observed performed stress (FDR PFP complete enriched identified patterns protein Fig). Physiol. based differential submergence, transcriptional transcripts variation visual Expression Maize RNA factors family indicates induced multiple provided ERFs NAM determined ethylene genetic mapping network oxygen scoring similar subset Gene PCR abundance analysis. candidate chromosome conditions inbreds. involved major phenotypic quantitative reported selected shoot showing tissue transcriptome unannotated up-regulated BINDING RAV RILs Transcription approximately considerably described down-regulated early genotypes. indicating leaves marker px; reads scored sequence set study survival {font-family C-REPEAT/DRE NAC Submergence damage families font-size genes. increase lines, log mapped mays notable oxidative package panel plant replicates results role species superoxide underlying (GRMZMG) (Zea ./pp.. Analysis Arabidopsis. Biol. File Fukao GRMZMG) Genes Lee MoW. RIL Table. USA). anaerobic cDNA cluster conducted delayed displayed diverse double; flooding highly known level lines. maize. method pathway population real-time samples. seedling seedlings shown significance staining waterlogging (GRMZMG); (XLSX) ./journal.pone. ATP Arabidopsis, Bot. DNA Exp FACTOR File). HEMOGLOBIN Mapping Mustroph Plants acid biological border-color border-width changes characterized co-expression collected conserved contrasting day derived following function gene, genotype identify indicate low maize, molecular number obtained parents pathways period phylogenetic plants. production proteins reactive recovery represented sample scale score senescence. sequencing solid; stage suggesting time tree {font-style {font-weight <.). (NAM) (a.) (b.) (c.) A). AP-ERF Acad Bailey-Serres Bayes Cell. Enrichment FRUCTOSE--PHOSPHATE GO:, GRMZMG Illumina Natl Nature. One. PDC Proc Rumex Sci Statistical Table). Tolerance Tolerant USA) USA. Zea Zhang activity alleles available bars basis bold cell cold conditions. considered controls. courier; credible determine different displaying downstream duration em; energy ethanol features fermentation formation founder generated genome glycolysis high homeostasis hypoxia hypoxic inbred independent involves mean members metabolism novel orthologous orthologs peroxide precipitation protocol pt;} redox region regulate regulated respectively responsive screening sequences signaling solution standard studies subfamilies synthesis thaliana total tubs up-regulation wheat


This div is smaller (width is 300px and height is 100px and has no padding).
This div is bigger (width is 300px and height is 100px and has 3rem padding).
This div is same size to below (width is 300px and height is 100px and has no padding).
This div is same size to above (width is 300px and height is 100px and has 3rem padding).


{% blocktranslate%} Django Girls global partners are hiring! Want to see your job posted here?
Contact us about becoming a global partner for Django Girls
and recruit the best talent for your organization. {% endblocktranslate %}
{% for job in job_list %}
{% if forloop.first %}
{% endif %}
{{ job.company.name }}
{% if job.date_created|timesince > "20 hours" %}
{% trans "New" %}
{% endif %}


xforms-valid and xforms-invalid events should be dispatched when a value conforms to or violates xf:bind/@constraint
baz
FALSE
-
Press the button labelled 'Test Validity'.
-
If the result field contains the text 'TEST PASSED', the test has passed. Otherwise, the test has failed.
Test Validity
Test:
Validity Result:
-
Press the button labelled 'Test Invalidity'.
-
If the result field contains the text 'TEST PASSED', the test has passed. Otherwise, the test has failed.
Test Invalidity
Test:
Invalidity Result:
Ready:


3 How to ask for help
The key to getting a useful answer to your R problem is asking a short but complete question. Frequently, this means to provide a reproducible example, which will allow someone else to reproduce your problem by copying and pasting your code. Four things make an example reproducible: a description of your R environment, required packages, code, and data. In BIOL 1001 and 1002, we provide the data that you will be using in the exercises, so it is unlikly that your issue is related to the data. We encourage you to follow the following steps:
Do your homework before asking. This step varies depending on where your problem is:
- If you have installation issues, double-check that you followed the instructions in R and RStudio and have downloaded and installed the correct versions of R and RStudio.
- If you have trouble with coding, first, locate the lines of code where the problem occurs. Copy your code from the beginning up to where the issue occurs. Then, start a new RStudio session, paste and run the code. Starting fresh will help you see if the same issue arises or if it was solved by removing unused elements.
- If the problem is caused by a function/command not running or not giving the expected output, follow Getting R help and read the help for the relevant functions/commands and how to use them.
- If you receive an error message or a warning, search the web by copying and pasting the output of R. It is likely that your R question has already been answered in websites like Stack Overflow. You can even search Twitter using ‘#rstats’.
- Finally, read over FAQ and other posts in the lab’s Discussion List to see if anyone else had a similar problem and how they solved it.
Write down your problem, succinctly. Try to simplify your problem as much as possible. Remember that you need to report the facts, so please do not write ‘R crashed’ or ‘function xyz doesn’t work’. Write exactly what happened, including any error messages R prompted. If you think that a function/command is not behaving sensibly, it’s more productive and polite to first, read the relevant documentation (see the previous step), and then ask why it acts the way it does.
Provide a short, reproducible example. First, try to locate which lines exactly result in the error. Please, do not copy and paste a whole function/chunk of code that gives an error. What is most useful is an accurate description of what commands you type until the problem happens. Do your best to remove everything that is not related to the problem. The shorter your code is, the easier it is to understand.
Ensure your code is easy for others to read. Make sure you have used spaces and your variable names are concise, but informative. This is also a good moment to check that your problem is not related to a typo in the name of an object. Remember that in R capitalization matters (e.g.
X
is not the same asx
). Use comments often to explain what you did and to indicate where your problem is. When you copy from the R console, take a few seconds to remove any ‘>’ and ‘+’. For example, if your code looks like this:
> x <- matrix(1:8, nrow=4, ncol=2,
dimnames=list(c("A","B","C","D"), c("x","y")))
> x
x y
A 1 5
B 2 6
C 3 7
D 4 8
question. You should also use
#
for outputs and comments, like this:# First, I define a matrix:
x <- matrix(1:8, nrow=4, ncol=2,
dimnames=list(c("A","B","C","D"), c("x","y")))
x
# x y
#A 1 5
#B 2 6
#C 3 7
#D 4 8
Check that you have made a reproducible example by starting up a new RStudio session, pasting your code from the step above and running it. In this way, you are sure that you made a piece of code that we can run to see the problem. Anyone should be able to copy and paste your code and data and get the same issue.
We need some facts about your machine, operating system, and version of R. To get this information, type the following command in the console:
sessionInfo()
. Paste the full output in your question. When mentioning version numbers, always use the complete version number, e.g., ‘2.6.1’, instead of ‘2.6’, and mention the platform (Windows, Linux, MacOS X, with their versions). We also need to check which version of RStudio you are using. For this, type in the consolerstudioapi::versionInfo()
and provide the full output in your question. If you have a package-specific problem, you should give its version by providing the output ofpackageVersion("name of the package")
.Before putting all of your code in an email, we encourage you to post it on the lab’s Discussion List. By doing this, we can help multiple people that may have the same problem at the same time. It also helps us to reply faster because we do not have to answer similar questions many times. Reading and commenting online is an essential component of learning programming, and it is one of the assets that makes R useful, more accessible and fun. The Discussion List is our small R community, and when you post on the Discussion List, we learn together.
An answer that is concise and technically accurate is just that, it is not intended as pedantic or an affront. Sometimes read the manual is the appropriate response to your question. Please be kind. Remember that we are trying to help you learn.
Example of a good question:
Subject: transform matrix to dataframe of specific dimensions.
# If I have a matrix x as follows:
x <- matrix(1:8, nrow=4, ncol=2,
dimnames=list(c("A","B","C","D"), c("x","y")))
x
How can I turn it into a dataframe with eight rows, and three columns named ‘row’, ‘col’, and ‘value’, which have the dimension names as the values of ‘row’ and ‘col’?


The Java class com.saxonica.Validate
allows you to validate
a source XML document against a given schema, or simply to check a schema for
internal correctness.
To validate a source document, write:
java com.saxonica.Validate [options] source.xml schema.xsd
The options must come first, then the file names.
To check a schema for internal correctness, write:
java com.saxonica.Validate -s [other-options] schema.xsd
The options are as follows (in any order):
|
-r classname |
Use the specified URIResolver to process all URIs. The URIResolver is a user-defined class, that implements the URIResolver interface defined in JAXP, whose function is to take a URI supplied as a string, and return a SAX InputSource. It is invoked to process URIs used in the doc() function, and (if -u is also specified) to process the URI of the source file provided on the command line. |
|
-s |
Schema check only. In this case, the source file name should be omitted. The program reads the supplied schema, checks it for internal consistency, reports any errors, and exits. |
|
-t |
Requests display of version and timing information to the standard error output. |
|
-u |
Indicates that the name of the source document and schema document are supplied as URIs; otherwise they are taken as filenames, unless they start with "http:" or "file:", in which case they they are taken as URLs. |
|
-x classname |
Requests use of the specified SAX parser for parsing the source file.
The classname must be the fully-qualified name
of a Java class that implements the |
|
-? |
Display command syntax |
|
source.xml |
Identifies the source file to be validated. This argument is mandatory unless the
|
|
schema.xsd |
Identifies the schema to be used for validation. This argument is mandatory if the
|
The results of processing the schema, and of validating the source document against the
schema, are written to the standard error output. Unless the -t
option is
used, successful processing of the source document and schema results in no output.


lcc.api package¶
Submodules¶
lcc.api.input_parse module¶
-
lcc.api.input_parse.
parse_query_ranges
(raw_params, split_by=':', enum_by=';')[source]¶ Parse range strings
Parameters: raw_params : list
List of strings which are composed of 0, 1 or 2 of split_by symbols.
split_by : str
Symbol which divides parameters ranges into from-to-step parts
Returns: list
List of lists of whole range of combinations for particular parameters
-
lcc.api.input_parse.
parse_tun_query
(raw_params)[source]¶ Parse query of merged identifiers with their parameters
Parameters: raw_params : list
List of dictionaries of: ‘name:params’ : value. For example [{‘VarioShapeDescr:alphabet_size’: 7, ...}, ..]
Returns: list
List of nested dictionaries. Keys are names of objects and their values are parameters (as keys for their values)
lcc.api.stars_handling module¶
-
lcc.api.stars_handling.
getStars
(queries, lcs_fold, query_path=None, progb_txt='Querying stars: ')[source]¶ Get stars from query text. According to format of the query text different methods are called.
- 1.QUERY:db_name:query_file_in_inputs_folder
- –> Remote database is queried (db key is name of connector class)
- 2.stars_folder_key:number or stars_folder_key:float_number or stars_folder_key
- –> Light curves from folder according to first key is loaded
- (according to settings.STARS_PATH dictionary). All stars are loaded if there is no number and ‘:’, in case of integer after ‘:’ just this number of stars are loaded and if there are float number after ‘:’ this percentage number of all stars are loaded.
-
lcc.api.stars_handling.
getStarsFromFolder
(single_path, lcs_fold)[source]¶ Get stars from folder/s. If path is iterable (case that more folders were given, light curves from that all folder will be loaded
Parameters: single_path : str
Name of the folder of lightcurves from “light_curve” directory (specified in settings).
Returns: stars : List of Star objects
Stars from the folder


If you see a little black clock icon in the build queue as shown below, it is an indication that your job is sitting in the queue unnecessarily.
The tool tip of the job name link next to the clock icon should tell you exactly why it is not building, but the common symptoms are as follows:
- Slaves are offline: your build needs to run on a particular slave, but the slave is offline.  Or better yet, use labels and do not tie builds to specific slaves, so that a single offline slave will not prevent your builds from starving.
- Waiting for an available executor on a slave: your build needs to run on a particular slave, but the slave is already fully busy building other things, and your build is waiting for "too long" compared to the time it takes to execute it — in other words, it does not make sense to wait for 5 minutes when the build itself finishes in 2 minutes. Use labels so that builds can run on any machine that satisfies the system requirements, and in this way you can add more slaves to improve the turn-around time.
- Waiting for an available executor on a label: all the slaves that have the given label are fully busy doing other things. It is time to add more slaves.
Attachments:
starvation.png (image/png)


make it happen brother
kosa
you have to do it tody dont think about yesterday if theres any problem call me


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use Species | |
|---|---|
| org.encog.ml.ea.genome | |
| org.encog.ml.ea.opp.selection | |
| org.encog.ml.ea.population | |
| org.encog.ml.ea.sort | |
| org.encog.ml.ea.species | |
| org.encog.ml.ea.train.basic |
| Uses of Species in org.encog.ml.ea.genome |
|---|
| Methods in org.encog.ml.ea.genome that return Species | |
|---|---|
Species |
BasicGenome.getSpecies()
|
Species |
Genome.getSpecies()
|
| Methods in org.encog.ml.ea.genome with parameters of type Species | |
|---|---|
void |
BasicGenome.setSpecies(Species s)
|
void |
Genome.setSpecies(Species s)
Set the species for this genome. |
| Uses of Species in org.encog.ml.ea.opp.selection |
|---|
| Methods in org.encog.ml.ea.opp.selection with parameters of type Species | |
|---|---|
int |
TruncationSelection.performAntiSelection(Random rnd,
Species species)
Selects an unfit genome. |
int |
SelectionOperator.performAntiSelection(Random rnd,
Species species)
Selects an unfit genome. |
int |
TournamentSelection.performAntiSelection(Random rnd,
Species species)
Selects an unfit genome. |
int |
TruncationSelection.performSelection(Random rnd,
Species species)
Selects an fit genome. |
int |
SelectionOperator.performSelection(Random rnd,
Species species)
Selects an fit genome. |
int |
TournamentSelection.performSelection(Random rnd,
Species species)
Selects an fit genome. |
| Uses of Species in org.encog.ml.ea.population |
|---|
| Methods in org.encog.ml.ea.population that return Species | |
|---|---|
Species |
BasicPopulation.createSpecies()
Create a species. |
Species |
Population.createSpecies()
Create a species. |
Species |
BasicPopulation.determineBestSpecies()
Determine which species has the top genome. |
Species |
Population.determineBestSpecies()
Determine which species has the top genome. |
| Methods in org.encog.ml.ea.population that return types with arguments of type Species | |
|---|---|
List<Species> |
BasicPopulation.getSpecies()
|
List<Species> |
Population.getSpecies()
|
| Uses of Species in org.encog.ml.ea.sort |
|---|
| Methods in org.encog.ml.ea.sort with parameters of type Species | |
|---|---|
int |
SpeciesComparator.compare(Species sp1,
Species sp2)
|
| Uses of Species in org.encog.ml.ea.species |
|---|
| Classes in org.encog.ml.ea.species that implement Species | |
|---|---|
class |
BasicSpecies
Provides basic functionality for a species. |
| Methods in org.encog.ml.ea.species that return Species | |
|---|---|
Species |
ThresholdSpeciation.findBestSpecies()
Find the best species. |
| Methods in org.encog.ml.ea.species with parameters of type Species | |
|---|---|
void |
ThresholdSpeciation.addSpeciesMember(Species species,
Genome genome)
Add a genome. |
void |
ThresholdSpeciation.removeSpecies(Species species)
Attempt to remove a removable species. |
| Uses of Species in org.encog.ml.ea.train.basic |
|---|
| Constructors in org.encog.ml.ea.train.basic with parameters of type Species | |
|---|---|
EAWorker(BasicEA theTrain,
Species theSpecies)
Construct the EA worker. |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


| Name |
Default |
Description |
| value: string |
|
Value of the input. If undefined, the component will be uncontrolled and
the value will be managed internally by the component.
|
| label: string |
|
Text to be placed above the input. Note that this prop will be reused for
the attribute aria-label of the suggestions list.
|
| name: string |
|
Name attribute of the input element. |
| helperText: string |
|
Helper text to be placed above the input. |
| placeholder: string |
|
Text to be put as placeholder of the input. |
| disabled: boolean |
false |
If true, the component will be disabled. |
| error: string |
|
If it is defined, the component will change its appearance, showing the
error below the input component. If it is not defined, the error messages will be created and managed internally.
|
| clearable: boolean |
false
|
If true, the input will have an action to clear the entered value.
|
| optional: boolean |
false
|
If true, the input will be optional, showing (Optional)
next to the label.
|
| onChange: EventEmitter |
|
This function will be called when the user types within the input. The new
value will be passed as a parameter.
|
| onBlur: EventEmitter |
|
This function will be called when the input loses the focus. An object
including the input value and the error (if the value entered is not
valid) will be passed to this function. An example of this object is:
{{ "{" }}
value: value, error: error
{{ "}" }}. If there is no error, error will be null.
|
| onActionClick: EventEmitter |
|
This function will be called when click in an action button. |
| margin: string | object |
|
Size of the margin to be applied to the component ('xxsmall' | 'xsmall' |
'small' | 'medium' | 'large' | 'xlarge' | 'xxlarge'). You can pass an
object with 'top', 'bottom', 'left' and 'right' properties in order to
specify different margin sizes.
|
| pattern: string |
|
Regular expression that defines the valid format allowed by the input.
This will be checked when the input loses the focus. If the value entered
does not match the pattern, the onBlur function will be called with the
value entered and the error informing that the value does not match the
pattern as parameters. If the pattern is accomplished, the error parameter
will be null.
|
| length: object |
|
Specifies the minimun and maximum length allowed by the input. It follows
this structure: {{ "{" }}
min: minLength, max: maxLength
{{ "}" }}. This will be checked when the user types within the input. If
the value entered does not comply the length, the onChange function will
be called with the value entered and the error informing that the value
does not comply the length as parameters. If the length is accomplished,
the error parameter will be null.
|
| size: string | object |
'medium'
|
Size of the component ('small' | 'medium' | 'large' | 'fillParent').
|
| suggestions: Array | function |
|
These are the options to be displayed as suggestions. It can be either an
array or a function:
-
Array: Array of options that will be filtered by the component.
-
Function: This function will be called when the user changes
the value, we will send as a parameter the new value; apart from that
this function should return one promise on which we should make 'then'
to get the suggestions filtered.
|
| tabIndex: number |
0
|
Value of the tabindex attribute. |


{{page.bio}}
{% capture excerpt %}{% include excerpts/{{ page.pid }}.md %}{% endcapture %}
{{ excerpt | markdownify }}
{{page.name}} was interviewed for Frontline Nurses by {{page.interviewed_by}} on {{page.interview_date}} in {{page.interview_city}}, {{page.interview_country}}.


A Working Example
This example shows :
how to run the program for some video
how to set some important parameters for the detection, view fixing and post processing
how to show the result
The detection part
The detection part is separated by loading a pretrained YOLOv4 network. The training should be done separately before running the tracking program.
The library that loads the structure of YOLO is part of the project (https://github.com/Tianxiaomo/pytorch-YOLOv4)
Using other detection trained model is also possible, it just needs to be loaded within the class YoloDetector
while changing the files directories in config file for the:
The model directory
The configuration file for Yolo network directory.
The names of the classes in a new file with the extention
.names
The training can be done in any library you want (tensorflow, Darknet). However, the result should be only in .pth
format.
After installing the library simply by running:
[1]:
!pip install -U offlinemot
Collecting offlinemot
Downloading offlinemot-1.0.3.tar.gz (28.1 MB)
---------------------------------------- 28.1/28.1 MB 10.7 MB/s eta 0:00:00
Preparing metadata (setup.py): started
Preparing metadata (setup.py): finished with status 'done'
Requirement already satisfied: numpy in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from offlinemot) (1.18.5)
Requirement already satisfied: opencv-contrib-python in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from offlinemot) (<IP_ADDRESS>)
Requirement already satisfied: scikit-image in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from offlinemot) (0.18.1)
Requirement already satisfied: torch in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from offlinemot) (1.10.2)
Requirement already satisfied: scipy in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from offlinemot) (1.4.1)
Requirement already satisfied: gdown in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from offlinemot) (4.3.1)
Requirement already satisfied: tqdm in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from gdown->offlinemot) (4.62.3)
Requirement already satisfied: requests[socks] in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from gdown->offlinemot) (2.25.1)
Requirement already satisfied: filelock in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from gdown->offlinemot) (3.6.0)
Requirement already satisfied: beautifulsoup4 in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from gdown->offlinemot) (4.8.1)
Requirement already satisfied: six in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from gdown->offlinemot) (1.14.0)
Requirement already satisfied: tifffile>=2019.7.26 in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from scikit-image->offlinemot) (2021.4.8)
Requirement already satisfied: PyWavelets>=1.1.1 in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from scikit-image->offlinemot) (1.1.1)
Requirement already satisfied: pillow!=7.1.0,!=7.1.1,>=4.3.0 in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from scikit-image->offlinemot) (8.2.0)
Requirement already satisfied: networkx>=2.0 in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from scikit-image->offlinemot) (2.5.1)
Requirement already satisfied: imageio>=2.3.0 in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from scikit-image->offlinemot) (2.9.0)
Requirement already satisfied: matplotlib!=3.0.0,>=2.0.0 in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from scikit-image->offlinemot) (3.4.2)
Requirement already satisfied: typing-extensions in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from torch->offlinemot) (<IP_ADDRESS>)
Requirement already satisfied: kiwisolver>=1.0.1 in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from matplotlib!=3.0.0,>=2.0.0->scikit-image->offlinemot) (1.1.0)
Requirement already satisfied: python-dateutil>=2.7 in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from matplotlib!=3.0.0,>=2.0.0->scikit-image->offlinemot) (2.8.1)
Requirement already satisfied: cycler>=0.10 in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from matplotlib!=3.0.0,>=2.0.0->scikit-image->offlinemot) (0.10.0)
Requirement already satisfied: pyparsing>=2.2.1 in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from matplotlib!=3.0.0,>=2.0.0->scikit-image->offlinemot) (2.4.7)
Requirement already satisfied: decorator<5,>=4.3 in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from networkx>=2.0->scikit-image->offlinemot) (4.4.1)
Requirement already satisfied: soupsieve>=1.2 in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from beautifulsoup4->gdown->offlinemot) (1.9.5)
Requirement already satisfied: urllib3<1.27,>=1.21.1 in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from requests[socks]->gdown->offlinemot) (1.26.3)
Requirement already satisfied: certifi>=2017.4.17 in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from requests[socks]->gdown->offlinemot) (2020.12.5)
Requirement already satisfied: chardet<5,>=3.0.2 in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from requests[socks]->gdown->offlinemot) (4.0.0)
Requirement already satisfied: idna<3,>=2.5 in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from requests[socks]->gdown->offlinemot) (2.10)
Requirement already satisfied: PySocks!=1.5.7,>=1.5.6 in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from requests[socks]->gdown->offlinemot) (1.7.1)
Requirement already satisfied: colorama in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from tqdm->gdown->offlinemot) (0.4.4)
Requirement already satisfied: setuptools in c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages (from kiwisolver>=1.0.1->matplotlib!=3.0.0,>=2.0.0->scikit-image->offlinemot) (59.5.0)
Building wheels for collected packages: offlinemot
Building wheel for offlinemot (setup.py): started
Building wheel for offlinemot (setup.py): finished with status 'done'
Created wheel for offlinemot: filename=offlinemot-1.0.3-py3-none-any.whl size=28144517 sha256=1bf6a028ccdc3857436c18197616d3086a37831681d2f967db9e335f31559740
Stored in directory: c:\users\yasin\appdata\local\pip\cache\wheels\8b\fd\9b\f9493bf735bb3b1a5574b65eaee317ea6036e880bf2b9e47b5
Successfully built offlinemot
Installing collected packages: offlinemot
Successfully installed offlinemot-1.0.3
WARNING: Ignoring invalid distribution -pencv-python (c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages)
WARNING: Ignoring invalid distribution -pencv-python (c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages)
WARNING: Ignoring invalid distribution -pencv-python (c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages)
WARNING: Ignoring invalid distribution -pencv-python (c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages)
WARNING: Ignoring invalid distribution -pencv-python (c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages)
WARNING: Ignoring invalid distribution -pencv-python (c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages)
WARNING: Ignoring invalid distribution -pencv-python (c:\users\yasin\appdata\local\programs\python\python37\lib\site-packages)
WARNING: You are using pip version 22.0.3; however, version 22.0.4 is available.
You should consider upgrading via the 'C:\Users\yasin\AppData\Local\Programs\Python\Python37\python.exe -m pip install --upgrade pip' command.
[2]:
import offlinemot
from offlinemot.detection import YoloDetector
This class YoloDetector
can take several input parameters, like the YOLO configuration file, the model file (in pytorch format), a flag to whether to use GPU or CPU and lastly a file containing the list of object names.
If there’s not a custom model to be loaded, then the default model can be loaded (as seen below). The example model will be downloaded when loading for the first time, this may take some time depending on your internet speed.
[3]:
cfg = offlinemot.config.configs()
detector = YoloDetector(cfg)
Detection is only performed every N frame. Where N is set according to configs
class instance. In the following sections there is a detailed description of all its parameters and their effects.
Note
A several testing with the parameters values maybe needed for different types of videos. Once a working set of values is found then all the similar videos can use the same set.
Config file content
To edit and show all these parameters, the following can be ran:
import offlinemot
cfg = offlinemot.config.configs()
cfg['detect_every_N'] = 3 #changing some value
cfg.print_summary() #showing the most important parameters and sections names
cfg.print_section('Detection') # showing the detection parameters
cfg.write('new.ini')
This will allow changes to all the parameters to be testsed and saved.
Detection and general configuration parameters
Other paramters influencing the detection and the general settings are:
### general parameters
draw = True
detect_every_N = 1
missing_thresh = 0.8
use_cuda = False
resize_scale = 0.4
colors_map = [ (0,255,0), # ped
(255,0,0), # cyclist
(0, 0, 0)] # cars
### Detection paramters
cwd = os.path.dirname(os.path.realpath(__file__))
model_name = os.path.join(cwd,'model','Yolov4_epoch300.pth')
model_config = os.path.join(cwd,'model','yolov4-obj.cfg')
classes_file_name= os.path.join(cwd,'model','obj.names')
detect_thresh = 0.3 #Yolo detection
# distance to the nearst match between detection and tracking
# output in pixels
dist_thresh = 25
size_thresh = 25
detect_scale = 4.0
The darwing flag
draw
, whether to draw or not.With this variable:
detect_every_N
, the number of detections frequency is determined. If high accuracy is needed then a value of 1 is optimal. Bigger values are less accurate but faster to run.The
missing_thresh
parameter is for determining when to delete an object if it keeps failing tracking and detection, it should be between 0 and 1, with 0 means never delete, and 1 delete on the first failure. A value of 0.9 means delete if 10% of result is failed, keep otherwise.The
use_cuda
flag is whether to use GPU for detection or CPU.The
resize_scale
is just for display (ifdraw
flag is True), to determine how much the image should be rescaled.The
colors_map
list is for the color code for the different detection outputs. The first element correspond to the class with id=1 out of the Yolo network.The
cwd
is the current directory of the config fileThe
model_name
is for the trained model file directoryThe
model_config
is for setting the parameters of the Yolo network, if a different structure is trained then a different file should be given here.The
class_file_name
is a text file contining the names of the predicted classes from the detection network.The
detect_thresh
is used to put a threshold on YOLO probabilty output for each detected class. The lower this value is the more detections it will give but with less accuracy.The
dist_thresh
is for matching each detection with already detected object, it shouldn’t be too big because it represents the minmum distance to match. Otherwise, false matching will be given.The
size_thresh
is another distance but to the change in width and height between a detection and a nearby object. It is used because the same object from bird’s eye view should have the same dimensions.The
detect_scale
is for smaller objects detection. sometimes the drone is too high and the objects are small, so we need to zoom in to detect in a better way. one solution here is to detect in two levels: full scale image in the ordinary case and smaller proposed cropped areas. This parameter control how small these areas are. Higher values will make the areas bigger.
Fixing and smoothing
In configs
class the following are the parameters for the part of fixing the view. The first boolean is for whether to do fixing or not. It will slow the processing, so if the video is stationary without noise then no need for it.
### fix view paramers
do_fix = False
fixing_dilation = 13
min_matches = 15
The part for doing the smoothing is also included in the same file as follows. The first boolean is whether to do the smoothing or not, the other two are related to Savitzky-Golay filter from scipy
library.
The last boolean flag save_out_video
will save a new mp4 file in the same folder as the video with the same name started with output_ if set to True. This will be run only with offlinemot.show_results.show_result()
### Smoothing for post processing
do_smooth = True
window_size = 7
polydegree = 3
save_out_video = False
Other steps (along with smoothing) are included in the postprocess.py
file, namely, the orientation calculation and interpolation of missing positions in the tracks. The orientation is calculated from the trajectory itself where the next point in the trajectory determines the current point heading.
Background subtraction parameters
Many parmeters are avaliable for background subtraction, as follows,
### background subtractor parameters
bgs_history = 5
bgs_threshold = 50
bgs_shadows = True
bgs_learning = 0.5
bgs_erosion_size = 3
bgs_min_area = 300
bgs_broder_margin = 0.45 # bigger would give boxes near the detected boxes with yolo
The most important of them are:
The
bgs_history
determines how many frames are used to calculate the backgroundThe
bgs_threshold
is realted to the sensativaty of the subtraction , lower values will give more sensativity to movementsThe
bgs_erosion_size
is the síze of the mask to perform erosion on the forground. higher values will give thiner objectsThe
bgs_min_area
determines the minmum area of pixels that will be considered as object, otherwise it will be deleted.THe
bgs_broder_margin
determines how mush overlapping is allowed between already detected objects and newly found forground. this number is considered a percentage of the detected object dimensions that objects are allowed to be in. For example a value of 0.5 will mean everywhere is allowed, because half of the dimension on all the objects means all the objects’ area.
Filering parameters
Additionally, in the configs
class, there’s parameters that will determine when to delete the detected objects.
### Filtering Objects:
min_history = 100
overlap_thresh = 0.7
The
min_hisory
is the minmum number of frames that the objects will start to be tested for percentage of correct tracking (withmissing_thresh
).The
overlap_thresh
is for the minmum area percentage of overlapping between confirmed objects to delete one of them.
How to run
To run for a new video, after setting the parameters, the command will be:
[6]:
offlinemot.core.extract_paths()# input your video path here (empty means the example video)
Used Parameters
====================
Groupus:
General parameters
Background subtractor
Fix view
Detection
Filtering
Smoothing
====================
General Parameters:
====================
draw:True
detect_every_n:1
missing_thresh:0.8
use_cuda:False
resize_scale:0.4
colors_map:[(0,255,0), (255,0,0), (0, 0, 0)]
WARNING:root:Some objects are detected but not moving or seen before
WARNING:root:Some objects are detected but not moving or seen before
WARNING:root:Some objects are detected but not moving or seen before
WARNING:root:Some objects are detected but not moving or seen before
WARNING:root:Some objects are detected but not moving or seen before
WARNING:root:Some objects are detected but not moving or seen before
WARNING:root:Some objects are detected but not moving or seen before
WARNING:root:Some objects are detected but not moving or seen before
WARNING:root:Some objects are detected but not moving or seen before
WARNING:root:Some objects are detected but not moving or seen before
WARNING:root:Some objects are detected but not moving or seen before
WARNING:root:Some objects are detected but not moving or seen before
and so on..
To stop the program at any point, simply press ESC
How to show result
After running the program on your video, a text file will be saved in same directory as the inputed video with the same name as well.
Warning
if there’s any text file with the same name of the video, then it will be overwritten without warning
If you want to show the result with angles and smoothing for the sample video above, you can run the command:
[7]:
import offlinemot
offlinemot.show_results.show_result(None,config=cfg)#put path of the video here (including extention, ex mp4, avi ..)
# None for the sample video
After running this command with your video path and extention (empty for an example), a new video will be written, if that is set in cfg
class, annotated with the tracked objects.
Output structure
in the output text file, each line is structured as follows,
Frame_id [ top_left_x top_left_y width height] class_id track_id angel
´39 [3748, 964, 169, 73] 2 5 138´
Above is an example of one line.


Guided Tours
New York, New York
$1,899 for 7 nights
botão
New York, New York
$1,899 for 7 nights
botão
New York, New York
$1,899 for 7 nights
botão


An online library
1. Choose a book you want from each genre's book list below.
2. Contact us and send us the following information:
- Full name
- Phone number
- Book you want to borrow
- Time and place to get the book
3. Borrowing rules:
- You cannot borrow more than 2 books each time
- Deposit 50% of the printed price on the book (This money will be given back when the book is returned on time and intact)
- Maximum borrowing time: 2 weeks. If you do not return the book after 2 weeks, we will keep your deposit.
4. Price:
- Vietnamese books: 5000 VND
- Foreign-language books: 10,000 VND
Note: This money will be used for buying more books, not for personal benefits.


Progress since the 2013 ECR and a look to the future
Created by
Jeroen De Dauw
for Wikimedia Deutschland
Licensed CC BY-SA 3.0
Some fun Wikibase.git stats
NCLOC - lines of code
58k → 95k
Classes
Class count: 417 → 602
→ 13% average class NCLOC increase
100 NCLOC → 112 NCLOC
Abstract classes
10% → 6%
Methods
Static: 11.3% → 8.7%
Public: 74% → 68%
NCLOC: 16 → 17
Cyclomatic complexity/methods: 2.12 → 2.02
Cause: MediaWiki hooks, misplaced code
Trend: Slowly decreasing, topic understood
Legacy interfaces:
API, SpecialPage, Action, Job, ContentHandler, Maintenance...
Trend:
Some new introductions, some partial cleanup
Not much change in technical debt
Solution:
Proper DI and disciplined handling of legacy APIs
Trend:
More awareness, though perhaps not enough
New issues still being introduced
Inheritance for code reuse:
API, SpecialPage, Entity, test cases...
Problems:
Complexity, fragility, opacity, immobility, SRP, LSP
Encouraged by lack of lifecycle control
Initial state:
Few, deprecated
Progress:
No new ones added, some removed
Only a few to go
PSR-0 was suggested
We now use PSR-0 or PSR-4
Except in Wikibase.git and part of Diff
Libraries use DI (+factories)
Repo and Client factories
DI approach from ECR implemented in WB Query
Suggested changes:
Decoupling from value objects
Progress:
Implemented nicely for Ask
Now migrating remaining code
ECR
Now
ECR
Now
Guess the NPath complexity!
17,336,096 (way over 9000)
Many function level issues
Method no longer critical, class is though
ECR: Possible SPR violation, split suggested
Status: done
ECR: Highest complexity, good tests recommended
Status: complexity reduced via method extraction
ECR suggested using the strategy pattern
Status: done
Implement DI → partial
Refactor EditEntity (API) using DI → fail
Refactor WB hooks using DI → fail


Thanks¶
Big thanks to all these people/projects without which enb would not be possible:
Core libraries¶
The enb core is firmly supported by the following key libraries:
Several other are also essential: please see the requirements in setup.py for more details.
Special thanks to all contributors to python itself. Without them, this library would have never been on time.
Plugin libraries¶
Many external libraries are employed by enb’s plugin system. Each offered plugin contains full reference to their respective authors, who also have enb’s eternal gratitude.
In addition, credits to (at least) the following people are due:
Ayushman Dash and Zhou Wang for their SSIM code
Geeks for Geeks for their snippet on CamelCase handling
Lorenzo for this post on argument parsing.
cgohlke for this post on easy PGM parsing.
Contributors¶
Special thanks to all contributors to the library’s codebase.


Valuing Basketball Players
Introduction
While I was growing up in San Antonio in the 2000’s, the one professional sports franchise in the area, the Spurs, were very good. We had the trio of Tim Duncan, Tony Parker, and Manu Ginobli, all legendary players in their own right. Between 1999 and 2014, this team brought home 5 championships and were one of the most dominant and consistent teams in American sports. The general discussion of the Spurs’ recent performance was inescapable, especially if it was a year they made it deep into the playoffs. Growing up in this environment, I developed a passing curiosity with basketball and the NBA, but not a deep fandom. So, when I found a large source of easily collectible basketball statistics, and knowing success about previous success in sports analytics, I decided to investigate the data.
My objective was to determine whether a player had performed in manner consistent with their salary. Players are expensive, and accurate appraisal of talent is important in building a strong team. In other words, I wanted to find out which players gave the most bang for your buck.
The plan was to build a model to predict the salaries of basketball players given their performance that year. The difference between my model’s prediction of the salary and their actual salary would be the amount by which they were being overpaid or underpaid. If somebody is being underpaid with regards to their stats, then
Data Collection
The first step in answering this question was to find the right data. I found this in basketball-reference.com, a wonderfully extensive resource containing anything basketball related that can be quantified. I performed web scraping using Beautiful Soup to collect all data for all teams (including all players) from 2008 to 2018, including salary information and salary cap information (more on why that’s important later).
Though I scraped as much info as I could from the the website, I only utilized a small selection. I focused on the per 36 minutes played statistics table and the Advanced Statistics table. (maybe include image here) An example of the per 36 minute statistics is Field Goals per 36 Minutes.
An example of an advanced statistic is PER or Player Efficiency Rating, which is calculated from a truly monstrous equation. I used the per 36 minute equations because I wanted to normalize the statistics for time on the court. One potential downside of this is that it may overvalue old players who can’t play for long periods of time, but are highly effective when on the court. I also wanted to use the advanced statistics because they represented some pre-engineered features of such high quality that I it would be foolish for me to not take advantage of them.
Regularization
One drawback of Ordinary Least Squares is that it can be prone to overfitting, especially when fitting on engineered features and polynomial features. LASSO and Ridge regression are two variants of OLS which are widely used in order to mitigate the problem of overfitting. Since I was working with a lot of features (over 50 in fact), I decided to use LASSO to cut out some of my extraneous feature. Utilizing LASSO (in combination with sklearn’s GridSearchCV
to select the appropriate regulzariztion parameter), I was able to cut myself down to 14 featuress.
The LASSO cost function tends to zero out a few parameters whereas Ridge tends to be more egalitarian in contraining parameter values. I chose to use LASSO over Ridge because my data exhibited a high degree of multicolinearity. In other words, a lot of my features were telling me the same thing. And since more features means more opportunity to fit to noise, cutting out redundant features will help my model generalize better.
Results
Now that I had a model predicted that how much a player was overpaid or underpaid, I identified the most overpaid and underpaid players for every year from 2011 to 2018. I have a detailed these results below:
Underpaid Players
| Name | Team | Year | Salary | Predicted Salary | Predicted Salary Error |
|---|---|---|---|---|---|
| Shaquille O’Neal | BOS | 2011 | $1,352,000 | $9,554,000 | $8,202,000 |
| Tracy McGrady | ATL | 2012 | $1,352,000 | $8,405,000 | $7,053,000 |
| Tim Duncan | SAS | 2013 | $9,638,000 | $17,077,000 | $7,438,000 |
| DeMarcus Cousins | SAC | 2014 | $4,917,000 | $12,956,000 | $8,039,000 |
| Pau Gasol | CHI | 2015 | $7,128,000 | $16,611,000 | $9,483,000 |
| Pau Gasol | CHI | 2016 | $7,449,000 | $19,362,000 | $11,913,000 |
| Giannis Antetokounmpo | MIL | 2017 | $2,995,000 | $20,495,000 | $17,500,000 |
| Dwyane Wade | MIA | 2018 | $1,471,000 | $17,827,000 | $16,356,000 |
Overpaid Players
| Name | Team | Year | Salary | Predicted Salary | Predicted Salary Error |
|---|---|---|---|---|---|
| Rashard Lewis | WAS | 2011 | $19,574,000 | $5,578,000 | -$13,996,000 |
| Rashard Lewis | WAS | 2012 | $21,137,000 | $5,537,000 | -$15,600,000 |
| Amar’e Stoudemire | NYK | 2013 | $19,949,000 | $6,814,000 | -$13,135,000 |
| Amar’e Stoudemire | NYK | 2014 | $21,680,000 | $6,537,000 | -$15,143,000 |
| Amar’e Stoudemire | NYK | 2015 | $23,411,000 | $8,337,000 | -$15,074,000 |
| Joe Johnson | BRK | 2016 | $24,894,900 | $9,114,000 | -$15,781,000 |
| Chandler Parsons | MEM | 2017 | $22,117,000 | $5,922,000 | -$16,195,000 |
| Mike Conley | MEM | 2018 | $28,530,000 | $11,148,000 | -$17,383,000 |
So, there you have it, the most underpaid and overpaid players between 2011 and 2018 in the NBA. I have similar information for every player in my dataset, but these were just the largest outliers and the most interesting examples.
While I do think these results are pretty decent, I want to stress some limitations of this model. First, I want to take a look at this residual plot.
A few notes:
- I’m predicting a few negative values. This may be worrisome, or it could be interpretted as players who are so bad that you should be willing to give up money in order to get them off your time. For instance, if there is a cost involved in a breaking a contract early, it still may be worth it to get them off your team.
- We’d ideally wish to have the slope of this line be about 1, but here it looks like it’s a little over . This means that our model tends to underpredicct the salary of players. For instance, some players command a full 40% of the salary cap, but my model doesn’t predict anything above about 30% of the cap.
So, that’s all I have for this project. I’ll link to the code soon and possibly update this with further thoughts on this project. I may try to extend this out to more years if I think it’s worthwhile. Thanks for reading!


{% extends "base.html" %} {% block content %} {% for acquisition in acquisitions %}
Title: {{ acquisition.book.title }}, Author: {{ acquisition.book.author }}


Toggle training panel.
Not Dab
Dab
Not Dab Samples:
Dab Samples:
Train Network
Click 'Start Predicting' to see predictions on if you're EXECUTIN' A DAB. Click 'Stop Predicting' to end.
Start Predicting
Stop Predicting
Download Model


--- layout: page_title title: titlename: about ---
shan2song.github.io.
Data ~ History.
Programming ~ Language.
Chemist. Pianist. Kindle person. Techo lover.
Caring about HEALTH and ENVIRONMENT.


Page 1 of 1
Video (killed the radio star?)
Posted:
Sun Mar 04, 2007 6:24 pm
by Karl G.
Posted:
Sun Mar 04, 2007 7:23 pm
by thadiusofx3
awesome, nice work
Posted:
Sun Mar 04, 2007 7:53 pm
by 9sam1
very cool. nice lvl 38 there karl
Posted:
Sun Mar 04, 2007 8:23 pm
by secretrk1313
Looks amazing man, sorry i have not got any plants for you yet, i have the flu and havent been on the computer much, Nice to see that something in there is called Dragon Sword though
Posted:
Tue Mar 06, 2007 10:48 pm
by Serenity
Cleaver LOL at that
Posted:
Wed Mar 07, 2007 7:42 am
by Karl G.
I just wanted an inventory that wasn't chock full of long swords.
Posted:
Wed Mar 07, 2007 3:02 pm
by Serenity
yeah, Imma Chop you up with mah meat cleaver
Posted:
Wed Mar 07, 2007 3:07 pm
by thadiusofx3
when you think we could see some videos of my models =P
Posted:
Wed Mar 07, 2007 7:35 pm
by Karl G.
They're not in the game yet...they'll come once I'm at the content stage. You could write the loading code though, if you can figure out how in the map editor
Posted:
Wed Mar 07, 2007 7:51 pm
by thadiusofx3
yeah i planned on doing that once i figured out all of your syntax for things =P
I wrote a loader for just a mesh viewer, but not inside of the map maker.
Posted:
Wed Mar 07, 2007 8:59 pm
by Karl G.
cool--is that MDJ mesh viewer or .X?
Posted:
Thu Mar 08, 2007 6:45 pm
by Nenitus
Ooh, looks nice.
But will you be doing the coloured for props convention?
I thought that was one of the most useful things EJ added in... it sure was a pain to look over every item when you were lookin for something cool
Posted:
Thu Mar 08, 2007 6:52 pm
by Karl G.
Yes, I believe we will do something like that. It's more of a "perk" than a real functionality issue, you understand. But it will come
Posted:
Thu Mar 08, 2007 7:39 pm
by thadiusofx3
.X, I've only really glanced at your mdj loader code
Posted:
Fri Mar 09, 2007 12:28 am
by Karl G.
Okay that's cool--definitely useful, too!
Posted:
Fri Mar 09, 2007 12:49 am
by thadiusofx3
It's in MDX
Posted:
Fri Mar 09, 2007 6:17 pm
by Ender
nice progress guys. I haven't been around much lately, but since spring break is coming up I should have some more free time soon and I'll start helping out with stuff again.


Models
There are no models in this project. You can add a model by using the Create menu above.
Failed
Created
by
Templates
Created
by
{{{slycat-injected-code}}}