This guest article was written by author and consultant Tristan Yates (see his bio below). It emphasizes R's data object manipulation and scoring capabilities via a detailed financial analysis example.

Scoring and ranking systems are extremely valuable management tools. They can be used to predict the future, make decisions, and improve behavior – sometimes all of the above. Think about how the simple grade point average is used to motivate students and make admissions decisions.

R is a great tool for building scoring and ranking systems. It’s a programming language designed for analytical applications with statistical capabilities. The capability to store and manipulate data in list and table form is built right into the core language.
 

But there’s also some validity to the criticism that R provides too many choices and not enough guidance. The best solution is to share your work with others, so in this article we show a basic design workflow for one such scoring and ranking system that can be applied to many different types of projects.

The Approach
For a recent article in Active Trader, we analyzed the risk of different market sectors over time with the objective of building less volatile investment portfolios. Every month, we scored each sector by its risk, using its individual ranking within the overall population, and used these rankings to predict future risk.

Here’s the workflow we used, and it can be applied to any scoring and ranking system that must perform over time (which most do):

1. Load in the historical data for every month and ticker symbol.
2. Load in the performance data for every month and ticker symbol.
3. Generate scores and rankings for every month and ticker symbol based upon their relative position in the population on various indicators.
4. Review the summary and look for trends.

In these steps, we used four data frames, as shown below:

Name	Contents
my.history	historical data
my.scores	scoring components, total scores, rankings
my.perf	performance data
my.summary	summary or aggregate data

 
One of my habits is to prefix my variables – it helps prevent collisions in the R namespace.

Some people put all of their data in the same data.frame, but keeping it separate reinforces good work habits. First, the historical data and performance data should never be manipulated, so it makes sense to keep it away from the more volatile scoring data.

Second, it helps draw a clear distinction between what we know at one point in time – which is historical data - and what we will know later – which is the performance data. That’s absolutely necessary for the integrity of the scoring system.

My.history, my.scores, and my.perf are organized like this:

yrmo	ticker	var1	var2	etc...
200401	XLF
200401	XLB
etc...

 
yrmo is the year and month and ticker is the item to be scored. We maintain our own list of dates (in yrmo format) and items in my.dates and my.items. Both these lists are called drivers, as they can help iterate through the data.frame, and we also have a useful data.frame called my.driver which has only the yrmo and ticker.

One trick – we keep the order the same for all of these data.frames. That way we can use indexes on one to query another. For example, this works just fine:

  Vol.spy <- my.history$vol.1[my.score$rank==1]

Loading Data
First, we get our driver lists and my.driver data.frame set up. We select our date range and items from our population, and then build a data.frame using the rbind command.

  #this is based on previous analysis
  my.dates <- m2$yrmo[13:(length(m2$yrmo)-3)]
  my.items <- ticker.list[2:10]

  #now the driver
  my.driver <- data.frame()
  for (z.date in my.dates) {
    my.driver <- rbind(my.driver,data.frame(ticker=my.items,yrmo=z.date))
  }

Next, let’s get our historical and performance data. We can make a function that can be called once for each row in my.driver that then loads any data needed.

  my.seq <- 1:length(my.driver[,1])
  my.history <- data.frame(ticker=my.driver$ticker,yrmo=my.driver$yrmo,
    vol.1=sapply(my.seq,calc.sd.fn,-1,-1))

Each variable can be loaded by a function called with the sapply command. The calc.sd.fn function first looks up the ticker and yrmo from my.driver using the index provided, and then returns the data. You would have one function for each indicator that you want to load. My.perf, which holds the performance data, is built in the exact same way.

The rbind command is slow unfortunately, but loading the historical and performance data only needs to be done once.

Scoring The Data
This is where R really shines. Let’s look at the highest level first.

  my.scores <- data.frame()
  for (z.yrmo in my.dates) {
    my.scores <- rbind(my.scores,calc.scores.fn(z.yrmo))
    }
  my.scores$p.tot <- (my.scores$p.vol.1)

Every indicator gets its own score, and then that can be combined in any conceivable way to create total score. In this very simple case, we’re only scoring one indicator, so we just use that score as the total score.

For more complex applications, the ideal strategy is to use multiple indicators from multiple data sources to tell the same story. Ignore those who advocate reducing variables and cross-correlations. Instead, think like a doctor that wants to run just one more test and get that independent confirmation.

Now the calc functions:

  scaled.score.fn <- function(z.raw)
    {pnorm(z.raw,mean(z.raw),sd(z.raw))*100}
  scaled.rank.fn <- function(z.raw) {rank(z.raw)}

  calc.scores.fn <- function(z.yrmo) {
    z.df <- my.history[my.history$yrmo==z.yrmo,]
    z.scores <- data.frame(ticker=z.df$ticker,yrmo=z.df$yrmo,
      p.vol.1=scaled.score.fn(z.df$vol.1),r.vol.1=scaled.rank.fn(z.df$vol.1))
    z.scores
    }

The calc.scores.fn function queries the data.frame to pull the population data for just a single point in time. Then, each indicator is passed to the scaled.score.fn and scaled.rank.fn function, returning a list of scores and ranks.

Here, we use the pnorm function to calculate a statistical Z-score, which is a good practice for ensuring that a scoring system isn’t dominated by a single indicator.

Checking the Scores
At this point, we create a new data.frame for summary analysis. We use the always useful and always confusing aggregate function and combine by rank. Notice how we easily we can combine data from my.history, my.scores and my.perf.

  data.frame(rank=1:9,p.tot=aggregate(my.scores$p.tot,
    list(rank=my.scores$r.vol.1),mean)$x,ret.1=aggregate(my.perf$ret.1,
    list(rank=my.scores$r.vol.1),mean)$x,sd.1=aggregate(my.perf$ret.1,
    list(rank=my.scores$r.vol.1),sd)$x,vol.1=aggregate(my.history$vol.1,
    list(rank=my.scores$r.vol.1),mean)$x,vol.p1=aggregate(my.history$vol.1,
    list(rank=my.scores$r.vol.1),mean)$x)

Here’s the result. We could check plots or correlations, but the trend – higher relative volatility in the past (vol.p1, p.tot) is more likely to mean higher relative volatility in the future (vol.1, sd.1) - is crystal clear.

rank	p.tot	ret.1	sd.1	vol.1	vol.p1
1	12.1	0.131	4.03	16.5	13.8
2	19.4	0.0872	4.82	16.6	16.1
3	27.1	0.2474	4.96	20.1	18
4	35.6	0.4247	5.31	20.9	19.9
5	44.9	0.6865	5.98	22.1	21.7
6	53	0.3235	5.84	21.5	23.2
7	65.1	1.019	5.86	24.6	25.4
8	78	0.7276	6.04	26.9	28.4
9	96.4	0.0837	9.34	35.2	38.3

 
In the case of our analysis, the scores aren’t really necessary – we’re only ranking nine items every month. If we did have a larger population, we could use code like this to create subgroups (six groups shown here), and then use the above aggregate function with the new my.scores$group variable.

  my.scores$group <- cut(my.scores$p.tot,
    breaks=quantile(my.scores$p.tot,(0:6)/6),include.lowest=TRUE,labels=1:6)

Wrap-up
We ultimately only ended up scoring one variable, but it’s pretty easy to see how this framework could be expanded to dozens or more. Even so, it’s an easy system to describe – we grade each item by its ranking within the population. People don’t trust scoring systems that can’t be easily explained, and with good reason.

There’s not a lot of code here, and that’s a testimony to R’s capabilities. A lot of housekeeping work is done for you, and the list operations eliminate confusing nested loops. It can be a real luxury to program in R after dealing with some other “higher level” language.

We hope you find this useful and encourage you to share your own solutions as well.

Tristan Yates is the Executive Director of Yates Management, a management and analytical consulting firm serving financial and military clients. He is also the author of Enhanced Indexing Strategies and his writing and research have appeared in publications including the Wall Street Journal and Forbes/Investopedia.

A mental model is simply a representation of an external reality inside your head. Mental models are concerned with understanding knowledge about the world.

While mental models can be traced back several decades in academic literature, they have been made part of every investors vocabulary because of Charlie Munger, Vice Chairman of Berkshire Hathaway.

via farnamstreetblog.com

The experience of signing in to your PC with touch has traditionally been a cumbersome one. In a world with increasingly strict password requirements—with numbers, symbols, and capitalization—it can take upwards of 30 seconds to enter a long, complex password on a touch keyboard. We have a strong belief that your experience with Windows 8 should be both fast and fluid, and that starts when you sign in.

There have been a lot of discussions, debates, blogs and papers about the advantages and disadvantages of sharing and publishing negative results from research in various fields of science.

SOPA and PIPA

Members of Congress are trying to do the right thing by going after pirates and counterfeiters but SOPA and PIPA are the wrong way to do it.

1. SOPA and PIPA would censor the Web

The U.S. government could order the blocking of sites using methods similar to those employed by China. Among other things, search engines could be forced to delete entire websites from their search results. That’s why 41 human rights organizations and 110 prominent law professors have expressed grave concerns about the bills.

2. SOPA and PIPA would be job-killers because they would create a new era of uncertainty for American business

Law-abiding U.S. internet companies would have to monitor everything users link to or upload or face the risk of time-consuming litigation. That’s why AOL, EBay, Facebook, Google, LinkedIn, Mozilla, Twitter, Yahoo and Zynga wrote a letter to Congress saying these bills “pose a serious risk to our industry’s continued track record of innovation and job-creation.” It’s also why 55 of America’s most successful venture capitalists expressed concern that PIPA “would stifle investment in Internet services, throttle innovation, and hurt American competitiveness”. More than 204 entrepreneurs told Congress that PIPA and SOPA would “hurt economic growth and chill innovation”.

3. SOPA and PIPA wouldn’t stop piracy

To make matters worse, SOPA and PIPA won’t even work. The censorship regulations written into these bills won’t shut down pirate sites. These sites will just change their addresses and continue their criminal activities, while law-abiding companies will suffer high penalties for breaches they can’t possibly control.

There are effective ways to combat foreign “rogue” websites dedicated to copyright infringement and trademark counterfeiting, while preserving the innovation and dynamism that have made the Internet such an important driver of American economic growth and job creation. Congress should consider alternatives like the OPEN Act, which takes targeted and focused steps to cut off the money supply from foreign pirate sites without making US companies censor the Web.

Great introduction to Ancient History with nice design

The formulation of a problem is often more essential than its solution, which may be merely a matter of mathematical or experimental skill. To raise new questions, new possibilities, to regard old problems from a new angle, requires creative imagination and marks real advance in science.

- Albert Einstein

An interactive tool that depicts the 500 companies on Fortune Magazine's annual list of America's largest corporations. Click and drag the mouse to see how a company's rank has changed over the years from 1955 to 2010. Or change to the Revenue and Profit views to see other perspectives.

H. Kemal İlter's articles on arXiv

[1] arXiv:1107.0202 [pdf]

Title: Revealing Sub-Optimality Conditions of Strategic Decisions

Authors: H. Kemal Ilter

Comments: 4 pages, 2 figures

Subjects: Other Statistics (stat.OT)

The web address for this page and the arXiv author id for H. Kemal İlter is http://arxiv.org/a/ilter_h_1. There is also an Atom feed available from http://arxiv.org/a/ilter_h_1.atom2 (authors combined, best for most current feed readers), and http://arxiv.org/a/ilter_h_1.atom (authors in separate atom:author elements).

See author identifier help for more information about arXiv author identifiers, please report any problems.

The Modes and Uses of Scientific Publication

Bertrand Meyer

September 24, 2011

Publication is about helping the advancement of humankind. Let us take this basis for granted and look at the other, possibly less glamorous aspects. Publication has four modes: Publicity; Exam; Business; and Ritual.

Evolutionary algorithms have been around since the early sixties. They apply the rules of nature: evolution through selection of the fittest individuals, the individuals representing solutions to a mathematical problem. Genetic algorithms are so far generally the best and most robust kind of evolutionary algorithms. They were invented by John Holland and presented in his book "Adaption in Natural and Artificial Systems" from 1975.

---

What makes a GA special?

What are the trademarks of a genetic algorithm (GA)? A GA is heuristic, which means it estimates a solution. You won't know if you get the exact solution, but that may be a minor concern. In fact, most real-life problems are like that: you estimate a solution rather than calculating it exactly.

For most problems you don't have any formula for solving the problem because it is too complex, or if you do, it just takes too long to calculate the solution exactly. An example could be space optimization - it is very difficult to find the best way to put objects of varying size into a room so they take as little space as possible. The most feasible approach then is to use a heuristic method.

Genetic algorithms are different from other heuristic methods in several ways. The most important difference is that a GA works on a population of possible solutions, while other heuristic methods use a single solution in their iterations. Another difference is that GAs are probabilistic (stochastic), not deterministic.

Each individual in the GA population represents a possible solution to the problem. The suggested solution is coded into the "genes" of the individual. One individual might have these genes: "1100101011", another has these: "0101110001" (just examples). The values (0 or 1) and their position in the "gene string" tells the genetic algorithm what solution the individual represents.

Here comes the clever part: you apply the rules of evolution to the individuals. You find the individuals you think are the best suggestions to your problem and then combine these individuals into new individuals. Using this method repeatedly, the population will hopefully evolve good solutions. Specifically, the elements of a GA are: selection (according to some measure of fitness), cross-over (a method of reproduction, "mating" the individuals into new individuals), and mutation (adding a bit of random noise to the off-spring, changing their "genes"). As you can see, Darwin's principles have been a major inspiration to GAs.

"GA" is a little applet that demonstrates the genetic algorithm, in which methods analogous to the process of natural evolution are applied to solve problems on a computer. This "artificial evolution" uses reproduction, mutation, and genetic recombination to "evolve" a solution to a problem. The genetic algorithm is described fully by John Holland in his book, "Adaptation in Natural and Artificial Systems." More popular accounts can be found in the books "Complexity" by M. Mitchell Waldrop and "Artificial Life" by Steven Levy.

The genetic algorithm can be applied to many different types of problems, but GA uses it to evolve simulated "organisms" called Eaters in a simulated world that contains simulated plants for the Eaters to eat. I stress the word "simulated", but even that word really goes too far. GA is really just a kind of metaphor for natural evolution in the real world. You can judge for yourself the extent to which that metaphor might be valid.

Time series prediction is a major task in many areas of research, e.g., biology, physics, business and engineering. The ability to forecast the behaviour of a system hinges, generally, on the knowledge of the laws underlying a given phenomenon. When this knowledge is expressed as a solvable equation, one can predict the behaviour along the future once the initial condition is given. However, phenomenological models are often unknown or extremely time consuming.