February | 2014 | Jamie Dixon's Home

Restaurant Classification Via the Yellow Pages API Using F#

February 25, 2014 1 Comment

As part of the restaurant analysis I did for open data day, I built a crude classifier to identify Chinese restaurants. The classifier looked at the name of the establishment and if certain key words were in the name, it was tagged as a Chinese restaurant.

member public x.IsEstablishmentAChineseRestraurant (establishmentName:string) =
    let upperCaseEstablishmentName = establishmentName.ToUpper()
    let numberOfMatchedWords = upperCaseEstablishmentName.Split(' ')
                                |> Seq.map(fun x -> match x with
                                                        | "ASIA" -> 1
                                                        | "ASIAN" -> 1
                                                        | "CHINA" -> 1
                                                        | "CHINESE" -> 1
                                                        | "PANDA" -> 1
                                                        | "PEKING" -> 1
                                                        | "WOK" -> 1
                                                        | _ -> 0)
                                |> Seq.sum
    match numberOfMatchedWords with
        | 0 -> false
        | _ -> true

Although this worked well enough for the analysis, I was interested in seeing if there was a way of using something that is more precise. To that end, I thought of the Yellow Pages – they classify restaurants into categories and assuming that the restaurant is in the yellow pages, it is a better way to determine the restaurant category versus just a name search.

The first thing I did was head over to the Yellow Pages (YP.com) website and sure enough, they have an API and a developers program. I signed up and had an API key within a couple of minutes.

The first thing I did was to try and search for a restaurant in the browser. I picked the first restaurant I came across in the dataset – Jumbo China #5. I created a request uri based on their API like so

http://pubapi.atti.com/search-api/search/devapi/search?term=Jumbo+China+5&searchloc=6108+Falls+Of+Neuse+Rd+27609&format=json&key=XXXXXXXXXX

When I plugged the name into the browser, I got this:

After screwing around with the code for about ten minutes thinking it was my API Key (Invalid Key would lead you to believe that, no?), Mike Thomas came over and told me that the url encoding was messing with my request – specifically the ‘#’ in Jumbo China #5. When I removed the # symbol, I got Json back:

Throwing the Json into Json2CSharp, the results look great:

I then took this URL and tried to load it into a F# type provider, I couldn’t understand why I was getting a red squiggly line of approbation (Json and XML):

so I pulled out Fiddler to see I was getting a 400. Digging into the response value, I found that “User Agent” was a required field.

The problem was then compounded because the FSharp Json type provider does not allow you to enter a User Agent into the constructor. I headed over to Stack Overflow where Thomas Petricek was kind enough to answer the question – basically you have to use the FSharp Http class to make the request (which you can add the user agent to) and then parse the response via the JsonProvider using the “Parse” versus the “Load” method. So spinning up the method like so:

This gave me the results back that I wanted. I then created a couple of methods to clean up any characters that might screw up the url encoding, added some argument validation, and I had a pretty good module to consume the YP.com listings:

namespace ChickenSoftware.RestaurantClassifier
 
open System
open FSharp.Data
open FSharp.Net
 
type ypProvider = JsonProvider< @"YP.txt">
 
type RestaurantCatagoryRepository() = 
   member this.GetCatagories(restaurantName: string, restaurantAddress: string) =
        if(String.IsNullOrEmpty(restaurantName)) then
            failwith("restaurantName cannot be null or empty.")
        if(String.IsNullOrEmpty(restaurantAddress)) then
            failwith("restaurantAddress cannot be null or empty.")
        let cleanedName = this.CleanName(restaurantName)
        let cleanedAddress = this.CleanAddress(restaurantAddress);
        let uri = "http://pubapi.atti.com/search-api/search/devapi/search?term=&quot;+cleanedName+"&searchloc="+cleanedAddress+"&format=json&key=XXXXXX"
        let response = FSharp.Net.Http.Request(uri, headers=["user-agent", "None"])
        let ypResult = ypProvider.Parse(response)
        try
            ypResult.SearchResult.SearchListings.SearchListing.[0].Categories
        with
            | ex -> String.Empty
 
    member this.CleanName(name: string) =
                name.Replace("#","").Replace(" ","+")
 
    member this.CleanAddress(address: string)=
                address.Replace("#","").Replace(" ","+")
    
    member this.IsCatagoryInCatagories(catagories: string, catagory: string) =
        if(String.IsNullOrEmpty(catagories)) then false
        else if (String.IsNullOrEmpty(catagory)) then false
        else catagories.Contains(catagory)
 
    member this.IsRestaurantInCatagory(restaurantName: string, restaurantAddress: string, restaurantCatagory: string) =
        if(String.IsNullOrEmpty(restaurantName)) then
            failwith("restaurantName cannot be null or empty.")
        if(String.IsNullOrEmpty(restaurantAddress)) then
            failwith("restaurantAddress cannot be null or empty.")
        if(String.IsNullOrEmpty(restaurantCatagory)) then
            failwith("restaurantCatagory cannot be null or empty.")
 
        System.Threading.Thread.Sleep(new System.TimeSpan(0,0,1))
        let catagories = this.GetCatagories(restaurantName, restaurantAddress)
        if(String.IsNullOrEmpty(catagories)) then false
        else this.IsCatagoryInCatagories(catagories,restaurantCatagory)
 
    member this.IsRestaurantInCatagoryAsync(restaurantName: string, restaurantAddress: string, restaurantCatagory: string) =
        async {
            if(String.IsNullOrEmpty(restaurantName)) then
                failwith("restaurantName cannot be null or empty.")
            if(String.IsNullOrEmpty(restaurantAddress)) then
                failwith("restaurantAddress cannot be null or empty.")
            if(String.IsNullOrEmpty(restaurantCatagory)) then
                failwith("restaurantCatagory cannot be null or empty.")
 
            let catagories = this.GetCatagories(restaurantName, restaurantAddress)
            if(String.IsNullOrEmpty(catagories)) then return false
            else return this.IsCatagoryInCatagories(catagories,restaurantCatagory)
        }

The associated unit and integration tests that I made in building this module look like this:

[TestClass]
public class CatagoryBuilderTests
{
 
    [TestMethod]
    public void CleanName_ReturnsExpectedValue()
    {
        RestaurantCatagoryRepository repository = new RestaurantCatagoryRepository();
        String restaurantName = "Jumbo China #5";
 
        String expected = "Jumbo+China+5";
        String actual = repository.CleanName(restaurantName);
        Assert.AreEqual(expected, actual);
    }
 
    [TestMethod]
    public void CleanAddress_ReturnsExpectedValue()
    {
        RestaurantCatagoryRepository repository = new RestaurantCatagoryRepository();
        String restaurantAddress = "6108 Falls Of Neuse Rd 27609";
 
        String expected = "6108+Falls+Of+Neuse+Rd+27609";
        String actual = repository.CleanAddress(restaurantAddress);
        Assert.AreEqual(expected, actual);
    }
 
 
    [TestMethod]
    public void GetCatagories_ReturnsExpectedValue()
    {
        string restaurantName = "Jumbo China #5";
        String restaurantAddress = "6108 Falls Of Neuse Rd 27609";
 
        RestaurantCatagoryRepository repository = new RestaurantCatagoryRepository();
        var result = repository.GetCatagories(restaurantName, restaurantAddress);
        Assert.IsNotNull(result);
    }
 
    [TestMethod]
    public void CatagoryIsContainedInCatagoriesUsingValidTrueData_ReturnsExpectedValue()
    {
        RestaurantCatagoryRepository repository = new RestaurantCatagoryRepository();
 
        String catagories = "Chinese Restaurants|Restaurants|";
        String catagory = "Chinese";
 
        Boolean expected = true;
        Boolean actual = repository.IsCatagoryInCatagories(catagories, catagory);
 
        Assert.AreEqual(expected, actual);
    }
 
    [TestMethod]
    public void CatagoryIsContainedInCatagoriesUsingValidFalseData_ReturnsExpectedValue()
    {
        RestaurantCatagoryRepository repository = new RestaurantCatagoryRepository();
 
        String catagories = "Chinese Restaurants|Restaurants|";
        String catagory = "Seafood";
 
        Boolean expected = false;
        Boolean actual = repository.IsCatagoryInCatagories(catagories, catagory);
 
        Assert.AreEqual(expected, actual);
    }
 
    [TestMethod]
    public void IsJumboChinaAChineseRestaurant_ReturnsTrue()
    {
        RestaurantCatagoryRepository repository = new RestaurantCatagoryRepository();
 
        string restaurantName = "Jumbo China #5";
        String restaurantAddress = "6108 Falls Of Neuse Rd 27609";
        String restaurantCatagory = "Chinese";
 
        Boolean expected = true;
        Boolean actual = repository.IsRestaurantInCatagory(restaurantName, restaurantAddress, restaurantCatagory);
 
        Assert.AreEqual(expected, actual);
    }
 
    [TestMethod]
    public void IsJumboChinaAnItalianRestaurant_ReturnsFalse()
    {
        RestaurantCatagoryRepository repository = new RestaurantCatagoryRepository();
 
        string restaurantName = "Jumbo China #5";
        String restaurantAddress = "6108 Falls Of Neuse Rd 27609";
        String restaurantCatagory = "Italian";
 
        Boolean expected = false;
        Boolean actual = repository.IsRestaurantInCatagory(restaurantName, restaurantAddress, restaurantCatagory);
 
        Assert.AreEqual(expected, actual);
    }
 
    [TestMethod]
    public void IsUnknownAnItalianRestaurant_ReturnsFalse()
    {
        RestaurantCatagoryRepository repository = new RestaurantCatagoryRepository();
 
        string restaurantName = "Some Unknown Restaurant";
        String restaurantAddress = "Some Address";
        String restaurantCatagory = "Italian";
 
        Boolean expected = false;
        Boolean actual = repository.IsRestaurantInCatagory(restaurantName, restaurantAddress, restaurantCatagory);
 
        Assert.AreEqual(expected, actual);
    }
 
 
 
    [TestMethod]
    public void CatagoryIsContainedInCatagoriesUsingEmptyCatagory_ReturnsExpectedValue()
    {
        RestaurantCatagoryRepository repository = new RestaurantCatagoryRepository();
 
        String catagories = "Chinese Restaurants|Restaurants|";
        String catagory = String.Empty;
 
        Boolean expected = false;
        Boolean actual = repository.IsCatagoryInCatagories(catagories, catagory);
 
        Assert.AreEqual(expected, actual);
    }

The hardest test to get run green was the negative test – passing in a restaurant name that is not recognized

[TestMethod]
public void IsUnknownAnItalianRestaurant_ReturnsFalse()
{
    RestaurantCatagoryRepository repository = new RestaurantCatagoryRepository();
 
    string restaurantName = "Some Unknown Restaurant";
    String restaurantAddress = "Some Address";
    String restaurantCatagory = "Italian";
 
    Boolean expected = false;
    Boolean actual = repository.IsRestaurantInCatagory(restaurantName, restaurantAddress, restaurantCatagory);
 
    Assert.AreEqual(expected, actual);
}

To code around the fact that a different set of Json came back and the original code is expecting a specific structure, I finally resorted to a try…catch

try
    ypResult.SearchResult.SearchListings.SearchListing.[0].Categories
with
    | ex -> String.Empty

I feel dirty, but I don’t know how else to get around it. In any event, I then coded up a module that pulled the list of restaurants from Azure and put them through the classifier.

namespace ChickenSoftware.RestaurantClassifier
 
open FSharp.Data
open System.Linq
open System.Configuration
open Microsoft.FSharp.Linq
open Microsoft.FSharp.Data.TypeProviders
 
type internal SqlConnection = SqlEntityConnection<ConnectionStringName="azureData">
 
type public RestaurantBuilder () =
    
    let connectionString = ConfigurationManager.ConnectionStrings.["azureData"].ConnectionString;
    
    member public this.GetRestaurants () =
        SqlConnection.GetDataContext(connectionString).Restaurants
            |> Seq.map(fun x -> x.EstablishmentName, x.EstablishmentAddress + " " + x.EstablishmnetZipCode)
            |> Seq.toArray
            
    member public this.GetChineseRestaurants () = 
        let catagoryRepository = new RestaurantCatagoryRepository()
        let catagory = "Chinese"
        this.GetRestaurants()
                |> Seq.filter(fun (name, address) -> catagoryRepository.IsRestaurantInCatagory(name, address,catagory))
                |> Seq.toList

This code is almost identical to the code I posted 2 weeks ago. Sure enough, When I threw my integration tests at the functions, check out fiddler.

I was getting responses. I ran into the problem on the 50th request though.

To get around this occasional timeout issue, I threw in a second delay between each request, which seemed the solve the problem.

System.Threading.Thread.Sleep(new System.TimeSpan(0,0,1))
let catagories = this.GetCatagories(restaurantName, restaurantAddress)
if(String.IsNullOrEmpty(catagories)) then false
else this.IsCatagoryInCatagories(catagories,restaurantCatagory)

However, this then introduced a new problem. There are 4,000 or so restaurants, so that is over 66 minutes of running. Not good. Next week, I hope to add some parallelism to speed things up…

Filed under F#, Open Data

Trigrams and F#

February 18, 2014 2 Comments

Rob Seder wrote a great post of trigrams last week. He then asked me how the same functionality would be implemented in F# – specifically dropping the for..each. Challenge accepted!.

The first thing I did was hit Stack Overflow to see if there is a built in function to parse a string by groups and I had a answer within minutes for exactly what I was looking for (thanks MattNewport).

So to match Rob’s BuildTrigram function, I wrote this:

type TrigramBuilder() = 
    member this.BuildTrigrams(inputString: string) =
        inputString
            |> Seq.windowed 3
            |> Seq.map(fun a -> System.String a)
            |> Seq.toArray

And I had a covering unit test already created:

[TestMethod]
public void GetTrigrams_ReturnsExpectedValue()
{
    var builder = new TrigramBuilder();
    String inputString = "ABCDEFG";
 
    String[] expected = new String[] { "ABC", "BCD", "CDE", "DEF", "EFG" };
    String[] actual = builder.BuildTrigrams(inputString);
 
    CollectionAssert.AreEqual(expected, actual);
}

I then Implemented a function that matches his double loops (can’t tell the function name from the code snippet on the blog post):

member this.GetMatchPercent(baseString: string, compareString: string) =
    let trigrams = this.BuildTrigrams(compareString)
    let matchCount = trigrams
                        |> Seq.map(fun t -> match baseString.Contains(t) with
                                                | true -> 1
                                                | false -> 0)
                        |> Seq.sum
    let totalCount = trigrams.Length
    float matchCount/float totalCount

And throwing in some covering unit tests:

public void GetMatchPercentageOfExactMatch_ReturnsExpectedValue()
{
    var builder = new TrigramBuilder();
    
    String baseString = "ABCDEF";
    String compareString = "ABCDEF";
 
    double expected = 1.0;
    double actual = builder.GetMatchPercent(baseString, compareString);
 
    Assert.AreEqual(expected, actual);
}
 
[TestMethod]
public void GetMatchPercentageOf50PercentMatch_ReturnsExpectedValue()
{
    var builder = new TrigramBuilder();
 
    String baseString = "ABCD";
    String compareString = "ABCDEF";
 
    double expected = 0.5;
    double actual = builder.GetMatchPercent(baseString, compareString);
 
    Assert.AreEqual(expected, actual);
}

Sure enough, green across the board:

Filed under F#

Analysis of Health Inspection Data using F#

February 11, 2014 4 Comments

As part of the TRINUG F#/Analytics SIG, I did a public records request from Wake County for all of the restaurant inspections in 2013. If you are not familiar, the inspectors go out and then give a score to the restaurant. The restaurant then has to display their score like this:

After some back and forth, I got the data as an Excel spreadsheet that looks like this

I then loaded the spreadsheet into a sql server and exposed it as some OData endpoints.

// GET odata/Restaurant
[Queryable]
public IQueryable<Restaurant> GetRestaurant()
{
    return db.Restaurants;
}
 
// GET odata/Restaurant(5)
[Queryable]
public SingleResult<Restaurant> GetRestaurant([FromODataUri] int key)
{
    return SingleResult.Create(db.Restaurants.Where(restaurant => restaurant.Id == key));
}

I then dove into the data to see if there were any interesting conclusions to be found. Following my pattern of doing analytics using F# and unit testing using C#, I created a project with the following code:

namespace ChickenSoftware.RestraurantChicken.Analysis
 
open System.Linq
open System.Configuration
open Microsoft.FSharp.Linq
open Microsoft.FSharp.Data.TypeProviders
 
type internal SqlConnection = SqlEntityConnection<ConnectionStringName="azureData">
 
type public RestaurantAnalysis () =
    
    let connectionString = ConfigurationManager.ConnectionStrings.["azureData"].ConnectionString;

Note that I am using the connection string in two places – the 1st for the type provider to do its magic at design time and the second for actually accessing the data at run time. With that set up, the 1st question I had was “ is there seasonality in inspection scores like there are in traffic tickets?” To that end, I created the following function:

member public x.GetAverageScoreByMonth () =
    SqlConnection.GetDataContext(connectionString).Restaurants
        |> Seq.map(fun x -> x.InspectionDate.Value.Month, x.InspectionScore.Value)
        |> Seq.groupBy(fun x -> fst x)
        |> Seq.map(fun (x,y) -> (x,y |> Seq.averageBy snd))
        |> Seq.map(fun (x,y) -> x, System.Math.Round(y,2))
        |> Seq.toArray
        |> Array.sort

This is pretty vanilla F# code, with the tricky part being the average by month (lines 4 and 5 here). What the code is doing is grouping up the 4,000 or so tuples that were created on line 3 into another tuple – with the fst being the groupBy value (in this case month) and then the second tuple being a tuple with the month and score. Then, by averaging up the score of the second tuple, we get an average for each month. I create a unit (really integration) test like so:

[TestMethod]
public void GetAverageScoreByMonth_ReturnsTwelveItems()
{
    var analysis = new RestaurantAnalysis();
    var scores = analysis.GetAverageScoreByMonth();
    Int32 expected = 12;
    Int32 actual = scores.Length;
    Assert.AreEqual(expected, actual);
}

And the result ran green.

Putting a break on the Assert and a watch on scores, you can see the values:

A couple of things stand out

1) The overall average is around 96 and change

2) There does not seem to be any significant variance among months.

Since I am trying to also teach myself D3, I then added a MVC5 project to my solution and added an analysis controller that calls the function in the analysis module and serves the results as json:

public JsonResult AverageScoreByMonth()
{
    var analysis = new RestaurantAnalysis();
    var scores = analysis.GetAverageScoreByMonth();
    return Json(scores,JsonRequestBehavior.AllowGet);
}

I then made a page with a simple D3 chart that calls this controller

@{
    Layout = "~/Views/Shared/_Layout.cshtml";
}
 
<svg class="chart"></svg>
 
<style>
    .bar {
        fill: steelblue;
    }
 
        .bar:hover {
            fill: brown;
        }
 
    .axis {
        font: 10px sans-serif;
    }
 
        .axis path,
        .axis line {
            fill: none;
            stroke: #000;
            shape-rendering: crispEdges;
        }
 
    .x.axis path {
        display: none;
    }
</style>
 
 
 
<script>
 
    var margin = { top: 20, right: 20, bottom: 30, left: 40 },
        width = 960 – margin.left – margin.right,
        height = 500 – margin.top – margin.bottom;
 
    var x = d3.scale.ordinal()
        .rangeRoundBands([0, width], .1);
 
    var y = d3.scale.linear()
        .range([height, 0]);
 
    var xAxis = d3.svg.axis()
        .scale(x)
        .orient("bottom");
 
    var yAxis = d3.svg.axis()
        .scale(y)
        .orient("left")
        .ticks(10, "%");
 
    var svg = d3.select("body").append("svg")
        .attr("width", width + margin.left + margin.right)
        .attr("height", height + margin.top + margin.bottom)
      .append("g")
        .attr("transform", "translate(" + margin.left + "," + margin.top + ")");
 
 
 
    $.ajax({
        url: "http://localhost:3057/Analysis/AverageScoreByMonth/&quot;,
        dataType: "json",
        success: function (data) {
            x.domain(data.map(function (d) { return d.Item1; }));
            y.domain([0, d3.max(data, function (d) { return d.Item2; })]);
 
            svg.append("g")
                .attr("class", "x axis")
                .attr("transform", "translate(0," + height + ")")
                .call(xAxis);
 
            svg.append("g")
                .attr("class", "y axis")
                .call(yAxis)
              .append("text")
                .attr("transform", "rotate(-90)")
                .attr("y", 6)
                .attr("dy", ".71em")
                .style("text-anchor", "end")
                .text("Frequency");
 
            svg.selectAll(".bar")
                .data(data)
              .enter().append("rect")
                .attr("class", "bar")
                .attr("x", function (d) { return x(d.Item1); })
                .attr("width", x.rangeBand())
                .attr("y", function (d) { return y(d.Item2); })
                .attr("height", function (d) { return height – y(d.Item2); });
 
        },
        error: function (e) {
            alert("error");
        }
    });
 
    function type(d) {
        d.Item2 = +d.Item2;
        return d;
    }
</script>

And when I run it, a run-of-the mill barchart (I did have to adjust the F# to shift the decimal to the left two positions so that I could match the scale of the chart’s template. For me, it is easier to alter the F# than the javascript:

Following this pattern, I did some other season analysis like average by DayOfMonth

DayOf Week.

So there does not seem to be any seasonality in inspection scores.

I then did an average of inspectors

And there looks to be some variance, but it is getting lost of the scale of the map. The problem is that the range of the scores is not 0 to 100

Here is a function that counts the number of scores (rounded to 0)

member public x.CountOfRoundedScores () =
    SqlConnection.GetDataContext(connectionString).Restaurants
        |> Seq.map(fun x -> System.Math.Round(x.InspectionScore.Value,0), x.InspectionID)
        |> Seq.groupBy(fun x -> fst x)
        |> Seq.map(fun (x,y) -> (x,y |> Seq.countBy snd))
        |> Seq.map(fun (x,y) -> (x,y |> Seq.sumBy snd))
        |> Seq.toArray

That graphically looks like:

So back to inspectors, I needed to adjust the scale from 0 to 100 to 80 to 100. I also needed to remove the null inspection Ids and the records that were for the ‘test facility’ and the 6 records that were below 80.

member public x.AverageScoreByInspector () =
    SqlConnection.GetDataContext(connectionString).Restaurants
        |> Seq.filter(fun x -> x.EstablishmentName <> "Test Facility")
        |> Seq.filter(fun x -> x.InspectionScore.Value > 80.)
        |> Seq.filter(fun x -> x.InspectionID <> null)
        |> Seq.map(fun x -> x.InspectorID, x.InspectionScore.Value)
        |> Seq.groupBy(fun x -> fst x)
        |> Seq.map(fun (x,y) -> (x,y |> Seq.averageBy snd))
        |> Seq.map(fun (x,y) -> x, y/100.)
        |> Seq.map(fun (x,y) -> x, System.Math.Round(y,4))
        |> Seq.toArray
        |> Array.sort

I then adjusted the scale of the inspector graph to have to domain from 80 to 100 (versus 0 to 100) and the scale of the y axis. This was a good article explaining Scales and Domains in D3.

var yAxis = d3.svg.axis()
    .scale(y)
    .orient("left")
    .ticks(10);

$.ajax({
    url: "http://localhost:3057/Analysis/AverageScoreByInspector/&quot;,
    dataType: "json",
    success: function (data) {
        x.domain(data.map(function (d) { return d.Item1; }));
        y.domain([80, d3.max(data, function (d) { return d.Item2; })]);

and now there is pretty good graph showing the variance among inspectors:

So the interesting this is that #1168 is 2 below the average – which of a domain of 10 is pretty significant. Interestingly, 1168 is also the inspector who has all of the “Test facility” records – so they are probably the trainer and/or lead inspector. With this analysis in the back pocket, ran a function that did the inspection score by establishment type:

This is kinda interesting (esp that pushcarts got the highest scores) but I wanted to see if there was any truth the the common perception that Chinese restaurants are less sanitary than other kinds of restaurants. To that end, I created a rudimentary classifier that searched the name of the establishment to see if it had a name that is typically associated with fast-food Chinese:

member public x.IsEstablishmentAChineseRestraurant (establishmentName:string) =
    let upperCaseEstablishmentName = establishmentName.ToUpper()
    let numberOfMatchedWords = upperCaseEstablishmentName.Split(' ')
                                |> Seq.map(fun x -> match x with
                                                        | "ASIA" -> 1
                                                        | "ASIAN" -> 1
                                                        | "CHINA" -> 1
                                                        | "CHINESE" -> 1
                                                        | "PANDA" -> 1
                                                        | "PEKING" -> 1
                                                        | "WOK" -> 1
                                                        | _ -> 0)
                                |> Seq.sum
    match numberOfMatchedWords with
        | 0 -> false
        | _ -> true

I then created a function that returned the average and ran my unit tests.

[TestMethod]
public void IsEstablishmentAChineseRestraurantUsingWOK_ReturnsTrue()
{
    var analysis = new RestaurantAnalysis();
    String establishmentName = "JAMIE'S WOK";
 
    var expected = true;
    var actual = analysis.IsEstablishmentAChineseRestraurant(establishmentName);
    Assert.AreEqual(expected, actual);
}
 
[TestMethod]
public void IsEstablishmentAChineseRestraurantUsingWok_ReturnsTrue()
{
    var analysis = new RestaurantAnalysis();
    String establishmentName = "Jamie's Wok";
 
    var expected = true;
    var actual = analysis.IsEstablishmentAChineseRestraurant(establishmentName);
    Assert.AreEqual(expected, actual);
}
 
[TestMethod]
public void AverageScoreForChineseRestaurants_ReturnsExpected()
{
    var analysis = new RestaurantAnalysis();
    var actual = analysis.AverageScoreForChineseRestaurants();
    Assert.IsNotNull(actual);
}

When a break was put on the value of the average, it was apparent that Chinese restaurants scored significantly lower than the average of 96

So then I applied 1 more segmentation: Chinese versus Non-Chinese scores by inspector:

member public x.AverageScoresOfChineseAndNonChineseByInspector () =
    let dataSet = SqlConnection.GetDataContext(connectionString).Restaurants
                    |> Seq.map(fun x -> x.EstablishmentName, x.InspectorID,x.InspectionScore.Value)
    let chineseRestraurants = dataSet
                                |> Seq.filter(fun (a,b,c) -> x.IsEstablishmentAChineseRestraurant(a))
                                |> Seq.map(fun (a,b,c) -> b,c)
                                |> Seq.groupBy(fun x -> fst x)
                                |> Seq.map(fun (x,y) -> (x,y |> Seq.averageBy snd))
                                |> Seq.map(fun (x,y) -> x, System.Math.Round(y,2))
                                |> Seq.toArray
                                |> Array.sort
    let nonChineseRestraurants = dataSet
                                |> Seq.filter(fun (a,b,c) -> not(x.IsEstablishmentAChineseRestraurant(a)))
                                |> Seq.map(fun (a,b,c) -> b,c)
                                |> Seq.groupBy(fun x -> fst x)
                                |> Seq.map(fun (x,y) -> (x,y |> Seq.averageBy snd))
                                |> Seq.map(fun (x,y) -> x, System.Math.Round(y,2))
                                |> Seq.toArray
                                |> Array.sort
    Seq.zip chineseRestraurants nonChineseRestraurants
           |> Seq.map(fun ((a,b),(c,d)) -> a,b,d)
           |> Seq.toList

And in graphics using a double-bar chart:

So this is kinda interesting. The lead inspector (1168) who grades everyone lower actually gives Chinese restaurants higher marks. Everyone else pretty much grades Chinese restaurants lower except for 1 inspector. Also, 1708 must really not like Chinese restaurants – or their inspection list has a series of really bad Chinese restaurants.

Note that this may not be statistically significant (I didn’t control for sample size, etc..) – but further analysis might be warranted, no? If you are interested, here is the endpoint: http://restaurantchicken.cloudapp.net/odata/Restaurant

Finally, when I presented this analysis to TRINUG last week, lots of people became interested in F# and analytics (ok, maybe 3). You can see the comments here. Also, I now have an appointment with the head of the health department department and the CIO of Wake County later this week – let’s see what they say…

Filed under Analytics, D3, F#

Unit Testing F# Projects

February 1, 2014 1 Comment

I am a big believer of unit tests and as I write more and more code, I suffer what sociologists call “confirmation bias” whereby I keep finding more and more reasons to confirm that I am right. But I am at the point where I don’t believe in developer documentation (sorry Sandcastle), reflector (sorry Redgate), code comments, or architectural diagrams. I believe in the code, the whole code, and nothing but the code. Or as Rasheed Wallace might say if he was a coder versus a professional basketball player: “Code Don’t Lie!”.

And the only code that tells you what a module is doing is the unit tests. If you want to see how the module behaves, look at the green unit tests. If you want to see how the module is supposed to behave but is not, look at the red unit tests. If you want to see how the module might or might behave because the code is out of control, look for the non-existent unit tests.

So when I started writing code in F#, the unit tests went along for the ride. F# folks will tell you to use the REPL to get your code working and/or use a unit test project in F#. I don’t do either because:

1) The REPL is designed for quick prototyping, not for having a durable, cantonal example of module behavior. Having a full suite of unit tests gives you code coverage, tests at the build, and a fail-proof way of documenting the code’s behavior.

2) Most of the other developers I work with are CSharpers. Having the unit tests in C# allows them to understand the behavior in a language in which they are familiar. Since the tests need to communicate the working code’s intent, having that in a language they understand is critical. They don’t have to understand F# to use a F# module. Also, porting from C# in MSTest to NUnit in C# is a snap.

So when you add a C# Unit Test project to your solution that has a F# module you want to test, there are a couple of things you need to do.

1) Add a reference from the Unit Test Project to the F# Project (Right Click, Add Reference)

2) Add a reference to F#

3) If you are using type providers (and who doesn’t) and you have the connection string in the .config file of the working code project, add a .config file to the unit test project and copy over the connection string

Note that you code has to reflect that the connection string is being used in 2 different ways by the type provider, as explained in this post. Your F# code needs to look like this:

type internal SqlConnection = SqlEntityConnection<ConnectionStringName="azureData">
 
 
type public RestaurantAnalysis () =
    
    let connectionString = ConfigurationManager.ConnectionStrings.["azureData"].ConnectionString;
    member public x.GetScoresByMonth () =
        SqlConnection.GetDataContext(connectionString).Restaurants
            |> Seq.map(fun x -> x.InspectionDate.Value.Month, x.InspectionScore.Value)
            |> Seq.groupBy(fun x -> fst x)
            |> Seq.toList

4) Finally, you have to rebuild the F# project each time you want the unit tests to pick up changes. That is different from a C# unit test project referencing a C# working code project.

Finally, not related to unit testing but too short for a blog post, if you are using the type providers (and who doesn’t) and you need to expose your classes publicly, you can’t use the SqlEntity provider – you need to use the SqlData provider. The catch is that SqlData does not work with Azure Sql Storage as far as I can tell. In my case, I used SqlEntity and exposed tuples and custom types publicly. Not the best, but still better than using C# and Entity Framework…

Filed under F#, Unit Testing || Mocking

Jamie Dixon's Home

Restaurant Classification Via the Yellow Pages API Using F#

Trigrams and F#

Analysis of Health Inspection Data using F#

Unit Testing F# Projects

Categories

Recent Posts

Archives

Blogroll

Meta