MY FIRST LOVE

README.md

A random sample of 750 Abalone measurements from UCI Machine Learning Repository.

Dataset Description

1. Title of Database: Abalone data

2. Sources:

   (a) Original owners of database:
  Marine Resources Division
  Marine Research Laboratories - Taroona
  Department of Primary Industry and Fisheries, Tasmania
  GPO Box 619F, Hobart, Tasmania 7001, Australia
  (contact: Warwick Nash +61 02 277277, wnash@dpi.tas.gov.au)

   (b) Donor of database:
  Sam Waugh (Sam.Waugh@cs.utas.edu.au)
  Department of Computer Science, University of Tasmania
  GPO Box 252C, Hobart, Tasmania 7001, Australia

   (c) Date received: December 1995


3. Past Usage:

   Sam Waugh (1995) "Extending and benchmarking Cascade-Correlation", PhD
   thesis, Computer Science Department, University of Tasmania.

   -- Test set performance (final 1044 examples, first 3133 used for training):
  24.86% Cascade-Correlation (no hidden nodes)
  26.25% Cascade-Correlation (5 hidden nodes)
  21.5%  C4.5
   0.0%  Linear Discriminate Analysis
   3.57% k=5 Nearest Neighbour
      (Problem encoded as a classification task)

   -- Data set samples are highly overlapped.  Further information is required
  to separate completely using affine combinations.  Other restrictions
  to data set examined.

   David Clark, Zoltan Schreter, Anthony Adams "A Quantitative Comparison of
   Dystal and Backpropagation", submitted to the Australian Conference on
   Neural Networks (ACNN'96). Data set treated as a 3-category classification
   problem (grouping ring classes 1-8, 9 and 10, and 11 on).

   -- Test set performance (3133 training, 1044 testing as above):
  64%    Backprop
  55%    Dystal
   -- Previous work (Waugh, 1995) on same data set:
  61.40% Cascade-Correlation (no hidden nodes)
  65.61% Cascade-Correlation (5 hidden nodes)
  59.2%  C4.5
  32.57% Linear Discriminate Analysis
  62.46% k=5 Nearest Neighbour


4. Relevant Information Paragraph:

   Predicting the age of abalone from physical measurements.  The age of
   abalone is determined by cutting the shell through the cone, staining it,
   and counting the number of rings through a microscope -- a boring and
   time-consuming task.  Other measurements, which are easier to obtain, are
   used to predict the age.  Further information, such as weather patterns
   and location (hence food availability) may be required to solve the problem.

   From the original data examples with missing values were removed (the
   majority having the predicted value missing), and the ranges of the
   continuous values have been scaled for use with an ANN (by dividing by 200).

   Data comes from an original (non-machine-learning) study:

  Warwick J Nash, Tracy L Sellers, Simon R Talbot, Andrew J Cawthorn and
  Wes B Ford (1994) "The Population Biology of Abalone (_Haliotis_
  species) in Tasmania. I. Blacklip Abalone (_H. rubra_) from the North
  Coast and Islands of Bass Strait", Sea Fisheries Division, Technical
  Report No. 48 (ISSN 1034-3288)


5. Number of Instances: 4177


6. Number of Attributes: 8


7. Attribute information:

   Given is the attribute name, attribute type, the measurement unit and a
   brief description.  The number of rings is the value to predict: either
   as a continuous value or as a classification problem.

  Name    Data Type Meas. Description
  ----    --------- ----- -----------
  Sex   nominal     M, F, and I (infant)
  Length    continuous  mm  Longest shell measurement
  Diameter  continuous  mm  perpendicular to length
  Height    continuous  mm  with meat in shell
  Whole weight  continuous  grams whole abalone
  Shucked weight  continuous  grams weight of meat
  Viscera weight  continuous  grams gut weight (after bleeding)
  Shell weight  continuous  grams after being dried
  Rings   integer     +1.5 gives the age in years

   Statistics for numeric domains:

    Length  Diam  Height  Whole Shucked Viscera Shell Rings
  Min 0.075 0.055 0.000 0.002 0.001 0.001 0.002     1
  Max 0.815 0.650 1.130 2.826 1.488 0.760 1.005    29
  Mean  0.524 0.408 0.140 0.829 0.359 0.181 0.239 9.934
  SD  0.120 0.099 0.042 0.490 0.222 0.110 0.139 3.224
  Correl  0.557 0.575 0.557 0.540 0.421 0.504 0.628   1.0


8. Missing Attribute Values: None


9. Class Distribution:

  Class Examples
  ----- --------
  1 1
  2 1
  3 15
  4 57
  5 115
  6 259
  7 391
  8 568
  9 689
  10  634
  11  487
  12  267
  13  203
  14  126
  15  103
  16  67
  17  58
  18  42
  19  32
  20  26
  21  14
  22  6
  23  9
  24  2
  25  1
  26  1
  27  2
  29  1
  ----- ----
  Total 4177

abalone.csv

index.html

<!DOCTYPE html>
<meta charset="utf-8">
<title>Abalone</title>
<script>
var margin = {top: 30, right: 40, bottom: 20, left: 50},
    width = 960 - margin.left - margin.right,
    height = 275 - margin.top - margin.bottom;
</script>
<style>
svg {
  font: 10px sans-serif;
}

.foreground path {
  fill: none;
  stroke: #222;
  stroke-opacity: 0.35;
  pointer-events: none;
  stroke-width: 1.5px;
}
 
.axis .title {
  font-size: 11px;
  font-weight: bold;
  text-transform: uppercase;
}

.axis line,
.axis path {
  fill: none;
  stroke: #000;
  stroke-width: 1px;
}

.brush .extent {
  fill-opacity: .3;
  stroke: #fff;
  stroke-width: 1px;
}

pre {
  width: 900px;
  margin: 10px 30px;
  tab-size: 15;
  font-size: 12px;
}
</style>
<body>
<script src="https://cdnjs.cloudflare.com/ajax/libs/d3/3.5.5/d3.min.js"></script>
<script>


var types = {
  "Number": {
    name: "Number",
    coerce: function(d) { return +d; },
    extent: d3.extent,
    within: function(d, extent) { return extent[0] <= d && d <= extent[1]; }
  },
  "String": {
    name: "String",
    coerce: String,
    extent: function (data) { return data.sort(); },
    within: function(d, extent, dim) { return extent[0] <= dim.scale(d) && dim.scale(d) <= extent[1]; }
  }
};

var dimensions = [
  {
    name: "Sex",
    scale: d3.scale.ordinal().rangePoints([0, height]),
    type: types["String"],
    domain: ["M", "F", "I"]
  },
  {
    name: "Length",
    scale: d3.scale.linear().range([height, 0]),
    type: types["Number"]
  },
  {
    name: "Diameter",
    scale: d3.scale.linear().range([height, 0]),
    type: types["Number"]
  },
  {
    name: "Height",
    scale: d3.scale.linear().range([height, 0]),
    type: types["Number"]
  },
  {
    name: "Whole weight",
    scale: d3.scale.linear().range([height, 0]),
    type: types["Number"]
  },
  {
    name: "Shucked weight",
    scale: d3.scale.linear().range([height, 0]),
    type: types["Number"]
  },
  {
    name: "Viscera weight",
    scale: d3.scale.linear().range([height, 0]),
    type: types["Number"]
  },
  {
    name: "Shell weight",
    scale: d3.scale.linear().range([height, 0]),
    type: types["Number"]
  },
  {
    name: "Rings",
    scale: d3.scale.linear().range([height, 0]),
    type: types["Number"]
  }
];

var color = d3.scale.ordinal()
  .range(["#1b9e77","#d95f02","#7570b3"]);

var x = d3.scale.ordinal()
    .domain(dimensions.map(function(dim) { return dim.name; }))
    .rangePoints([0, width]);

var line = d3.svg.line()
    .defined(function(d) { return !isNaN(d[1]); });

var yAxis = d3.svg.axis()
    .orient("left");

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 + ")");

var output = d3.select("body").append("pre");

var dimension = svg.selectAll(".dimension")
    .data(dimensions)
  .enter().append("g")
    .attr("class", "dimension")
    .attr("transform", function(d) { return "translate(" + x(d.name) + ")"; });

var colordimension = dimensions[0];

d3.csv("abalone.csv", function(error, rawdata) {
  if (error) throw error;

  // take subset of data
  data = d3.shuffle(rawdata).slice(0,750);

  data.forEach(function(d) {
    dimensions.forEach(function(p) {
      d[p.name] = p.type.coerce(d[p.name]);
    });
  });

  dimensions.forEach(function(dim) {
    if (!("domain" in dim)) {
      // detect domain using dimension type's extent function
      dim.domain  = d3.functor(dim.type.extent)(data.map(function(d) { return d[dim.name]; }));
    }
    dim.scale.domain(dim.domain);
  });

  color.domain(colordimension.scale.domain());

  svg.append("g")
      .attr("class", "foreground")
    .selectAll("path")
      .data(data)
    .enter().append("path")
      .attr("d", draw)
      .style("stroke", function(d) { return color(d[colordimension.name]); });

  dimension.append("g")
      .attr("class", "axis")
      .each(function(d) { d3.select(this).call(yAxis.scale(d.scale)); })
    .append("text")
      .attr("class", "title")
      .attr("text-anchor", "middle")
      .attr("y", -9)
      .text(function(d) { return d.name; });

  // Add and store a brush for each axis.
  dimension.append("g")
      .attr("class", "brush")
      .each(function(d) {
        d3.select(this).call(d.brush = d3.svg.brush()
          .y(d.scale)
          .on("brushstart", brushstart)
          .on("brush", brush));
      })
    .selectAll("rect")
      .attr("x", -8)
      .attr("width", 16);

  output.text(d3.tsv.format(data));

  function draw(d) {
    return line(dimensions.map(function(dim) {
      return [x(dim.name), dim.scale(d[dim.name])];
    }));
  }

  function brushstart() {
    d3.event.sourceEvent.stopPropagation();
  }

  // Handles a brush event, toggling the display of foreground lines.
  function brush() {
    var actives = dimensions.filter(function(p) { return !p.brush.empty(); }),
        extents = actives.map(function(p) { return p.brush.extent(); });

    var selected = [];

    d3.selectAll(".foreground path").style("display", function(d) {
      if (actives.every(function(dim, i) {
          // test if point is within extents for each active brush
          return dim.type.within(d[dim.name], extents[i], dim);
        })) {
        selected.push(d);
        return null;
      }
      return "none";
    });

    output.text(d3.tsv.format(selected));
  }
});

</script>

thumbnail.png