Tải bản đầy đủ


Tải bản đầy đủ

4.7  Usage Syntax and Examples for Major Database Servers   125

pool performance. The cost of using views to fulfill roles is small, because renaming operations require few system resources.

We give a few concrete examples utilizing specific commercial products in this
section to illustrate the implementation of some of the concepts we’ve discussed.
Recommendations for more complete coverage of specific products are given in
the Literature Summary section at the end of the chapter.

4.7.1  Oracle
Oracle offers many ways of partitioning data, including by range, by list, and by
hash value. Each partition can reside in its own tablespace. A tablespace in Oracle
is a physical location for storing data.
Partitioning by range allows data to be stored in separate tablespaces based on
specified value ranges for each partition. For example, we may want to separate
historical data from recent data. If recent data changes frequently, then isolating
the recent data in a smaller partition can improve update performance. The following is the definition of a materialized view for labor costs by repair date,
partitioned into historical and recent data, with 2006 acting as the dividing
CREATE MATERIALIZED VIEW mv_labor_cost_by_repair_date
(PARTITION repair_to_2006 VALUES LESS THAN (2006)
TABLESPACE repairs_historical,
TABLESPACE repairs_recent)
SELECT w.repair_date_id, repair_year, sum(labor_cost)
FROM warranty_claim w, repair_date r
WHERE w.repair_date_id=r.repair_date_id
GROUP BY w.repair_date_id, repair_year;

If the values of a column are discrete but do not form natural ranges, the rows
can be assigned to partitions according to defined lists of values. Here is a definition for a materialized view that partitions the rows into east, central, and west,
based on value lists:
CREATE MATERIALIZED VIEW mv_labor_cost_by_location
(PARTITION east VALUES(‘Northeast’,’Southeast’)
PARTITION central VALUES(‘Midwest’,’Westcentral’)

126    CHAPTER 4  Physical Design for Decision Support

PARTITION west VALUES(‘West’,’Southwest’)
SELECT w.loc_id, region, sum(labor_cost)
FROM warranty_claim w, location l
WHERE w.loc_id=l.loc_id
GROUP BY w.loc_id, region;

Often, it is desirable to divide the data evenly between partitions, facilitating
the balancing of loads over multiple storage devices. Partitioning by hash values
may be a good option to satisfy this purpose. Here is a materialized view definition
that divides the labor cost by repair date rows into three partitions based on
CREATE MATERIALIZED VIEW mv_labor_cost_by_repair_date
PARTITION BY HASH(repair_date_id)
PARTITIONS 3 STORE IN (tablespace1, tablespace2, tablespace3)
SELECT repair_date_id, sum(labor_cost)
FROM warranty_claim
GROUP BY repair_date_id;

Partition by hash may not work well in the case where the distribution of
values is highly skewed. For example, if 90 percent of the rows have a given value,
then at least 90 percent of them will map to the same partition, no matter how
many partitions we use and no matter what hash function the system uses.

4.7.2  Microsoft’s Analysis Services
Microsoft SQL Server 2005 Analysis Services supported OLAP and data mining
operations. The analysis manager is used to specify a data source. Many options
are supported for the data source, including Open DataBase Connectivity (ODBC)
data sources. A database connection can be established to a Microsoft SQL Server
database (or any other ODBC-compliant database). The dimension tables and fact
tables are specified using GUI screens, and the data cube is then built. There are
a series of options available including ROLAP, HOLAP, and MOLAP. There are also
several options for specifying limits on the use of aggregates. The user can specify
a space limit.
Figure 4.10 shows a screen from the Storage Design Wizard. The wizard selects
views to materialize while displaying the progress in graph form. Note that
Microsoft uses the term “aggregations” instead of materialized views in this
context. OLAP systems improve performance by precalculating views and materializing the results to disk. Queries are answered from the smaller aggregations
instead of reading the large fact table. Typically, there are far too many possible
views to materialize them all, so the OLAP system needs to pick strategic views
for materialization.
In Microsoft Analysis Services, you have several options to control the process.
You may specify the maximum amount of disk space to use for the aggregates.

4.7  Usage Syntax and Examples for Major Database Servers   127

Print screen from Microsoft Analysis Services, Storage Design Wizard.

You also have the option of specifying the performance gain. The higher the
performance gain, the more disk space is required. The Microsoft documentation
recommends a setting of about 30 percent for the performance gain. Selecting a
reasonable performance gain setting is problematic, because the gain is highly
dependent on the data. The views are picked for materialization using a greedy
algorithm, so the graph will indicate a trend toward diminishing returns. You can
watch the gain on the graph and click the stop button anytime you think the gain
is not worth the disk space and the associated update costs. Also, if your specified
gain is reached and the curve is not leveling out, you can reset the gain higher
and continue if you wish.

Tip 1. The dimensional design approach is appropriate for designing
a data warehouse. The resulting star schemas are much more efficient
than normalized tables in the context of a data warehouse.
Tip 2. Use star schemas rather than snowflake schemas. Star schemas
require fewer joins, and the schemas are more intuitive for users.
Tip 3. Conform dimensions across all business processes. Discussions
between different groups of users are more fruitful if terms carry the same
meaning across the entire enterprise.

128    CHAPTER 4  Physical Design for Decision Support

Tip 4. Index dimension attributes with bitmap indexes when the
attribute has a small to medium cardinality of distinct values. The
bitmap indexes are efficient for star joins.
Tip 5. Use materialized views when advantageous for speeding up
throughput. Note that OLAP systems automatically select views for materialization.
Tip 6. Use appropriate update strategies for refreshing materialized
views. Typically this means incremental updates during a designated
update window each night. However, company requirements may dictate
a real-time update strategy. Occasionally, when the nature of the data leads
to changes of large portions of a materialized view, it may be more efficient
to run a complete refresh of that materialized view.
Tip 7. If your OLAP system offers both ROLAP and MOLAP storage
options, use MOLAP only if the data is dense. ROLAP is more efficient
when the data is sparse. ROLAP is good overall, but MOLAP does not scale
well to large, sparse data spaces.
Tip 8. When datasets become huge, utilize partitioning and parallel
processing to improve scalability. Shared nothing systems are massively parallel processing platforms that have become extremely popular
for data warehousing. In general, once a data warehouse or data mart grows
larger than ~500GB of raw data (size before loading into the database),
shared nothing architectures will generally provide a superior architectural
platform compared to scaleup solutions that simply grow the database
server resources within a single box.
Tip 9. Don’t go nuts with dimension tables. Additional tables in the
system add complexity to the query execution plan selection process.
Simply put, every table that needs to be joined can be joined in multiple
ways (hash join, nested loop join, merge join, etc.). As the number of tables
to join grows, the join enumeration grows, and therefore so does the compilation complexity. As a result, a large number of dimension tables can
cause increased complexity (and opportunity for error) within the query
compiler. Therefore, for very narrow dimension tables, 20 bytes wide or
less, consider denormalizing them. This is one of the practical trade-offs
between design purity and real world practicality.

The decision support technologies of data warehousing and OLAP are overviewed
in this chapter. Some of the physical design issues are described, and some of the
solutions are illustrated with examples. The use of materialized views for faster
query response in the data warehouse environment is discussed. The different

Resources   129

general categories of OLAP storage are described, including ROLAP, MOLAP, and
HOLAP, along with general guidelines for determining when one may be more
appropriate than the others, based on data density. The dimensional design
approach is covered briefly, with examples illustrating star and snowflake schemas.
The usefulness of the data warehouse bus is demonstrated with an example,
showing the relationship of conformed dimensions across multiple business processes. The data warehouse bus leads to a data warehouse constellation schema
with the possibility of developing a data mart for each business process. Approaches
toward efficient processing are discussed, including some hardware approaches,
the appropriate use of bitmap indexes, various materialized view update strategies, and the partitioning of data.
Data warehousing offers the infrastructure critical for decision support based
on large amounts of historical data. OLAP is a service that offers quick response
to queries posed against the huge amounts of data residing in a data warehouse.
Data warehousing and OLAP technologies allow for the exploration of data,
facilitating better decisions by management.

The books by Kimball et al. offer detailed explanations and examples for various
aspects of data warehouse design. The book The Data Warehouse Toolkit: The
Complete Guide to Dimensional Modeling is a good starting point for those
interested in pursuing data warehousing. The ETL process is covered in The Data
Warehouse ETL Toolkit.
Product-specific details and examples for Oracle can be found in Oracle Data
Warehouse Tuning for 10 g by Powell. SQL Server Analysis Services 2005 with
MDX by Harinath and Quinn is a good source covering Microsoft data warehousing, OLAP, and data mining.
The Patent Office web site takes some getting used to, but the effort can be
well worth it if you want to learn about emerging technology. Be prepared to sift,
because not every patent is valuable. You may discover what your competition is
pursuing, and you may find yourself thinking better ideas of your own.

Harinath, S., and S. Quinn. SQL Server Analysis Services 2005 with MDX, John Wiley,
Hindshaw, F., J. Metzger, and B. Zane. Optimized Database Appliance, Patent No. U.S.
7,010,521 B2, Assignee: Netezza Corporation, Framingham, MA, issued March 7, 2006.
IBM Data Warehousing, Analysis, and Discovery: Overview. IBM Software—www-306.ibm.

130    CHAPTER 4  Physical Design for Decision Support

Kimball, R., L. Reeves, M. Ross, and W. Thornthwaite. The Data Warehouse Life Cycle
Toolkit, John Wiley, 1998.
Kimball, R., and M. Ross. The Data Warehouse Toolkit: The Complete Guide to Dimensional Modeling, 2nd ed., John Wiley, 2002.
Kimball, R., and J. Caserta. The Data Warehouse ETL Toolkit, 2nd ed., John Wiley, 2004.
Microsoft SQL Server: Business Intelligence Solutions—www.microsoft.com/sql/solutions/
Netezza Corporation, at netezza.com.
Oracle Business Intelligence Solutions—www.oracle.com/solutions/business_intelligence/
Patent Full-Text and Full-Page Image Databases—www.uspto.gov/patft/index.html.
Powell, G. Oracle Data Warehouse Tuning for 10g, Elsevier, 2005.
Teorey, T., S. Lightstone, and T. Nadeau. Database Modeling and Design: Logical Design,
4th ed., Morgan Kaufmann, 2006.


Algorithms: The Basic


Now that we’ve seen how the inputs and outputs can be represented, it’s time to
look at the learning algorithms themselves. This chapter explains the basic ideas
behind the techniques that are used in practical data mining. We will not delve
too deeply into the trickier issues—advanced versions of the algorithms, optimizations that are possible, complications that arise in practice.
In this chapter we look at the basic ideas. One of the most instructive lessons
is that simple ideas often work very well, and we strongly recommend the adoption of a “simplicity-first” methodology when analyzing practical datasets. There
are many different kinds of simple structure that datasets can exhibit. In one
dataset, there might be a single attribute that does all the work and the others
may be irrelevant or redundant. In another dataset, the attributes might contribute
independently and equally to the final outcome. A third might have a simple logical
structure, involving just a few attributes that can be captured by a decision tree.
In a fourth, there may be a few independent rules that govern the assignment of
instances to different classes. A fifth might exhibit dependencies among different
subsets of attributes. A sixth might involve linear dependence among numeric
attributes, where what matters is a weighted sum of attribute values with appropriately chosen weights. In a seventh, the distances between the instances themselves might govern classifications appropriate to particular regions of instance
space. And in an eighth, it might be that no class values are provided: the learning
is unsupervised.
In the infinite variety of possible datasets, many different kinds of structure
can occur, and a data mining tool—no matter how capable—that is looking for
one class of structure may completely miss regularities of a different kind, regardless of how rudimentary those may be. The result is one kind of baroque and
opaque classification structure instead of a simple, elegant, immediately comprehensible structure of another.
Each of the eight examples of different kinds of datasets sketched previously
leads to a different machine learning method well suited to discovering it. The
sections of this chapter look at each of these structures in turn.

132    CHAPTER 5  Algorithms: The Basic Methods

Here’s an easy way to find simple classification rules from a set of instances. Called
1R for 1-rule, it generates a one-level decision tree expressed in the form of a set
of rules that all test one particular attribute. 1R is a simple, cheap method that
often comes up with good rules for characterizing the structure in data. It turns
out that simple rules frequently achieve surprisingly high accuracy. Perhaps this
is because the structure underlying many real-world datasets is rudimentary, and
just one attribute is sufficient to determine the class of an instance accurately. In
any event, it is always a good plan to try the simplest things first.
The idea is this: We make rules that test a single attribute and branch accordingly. Each branch corresponds to a different value of the attribute. It is obvious
what is the best classification to give each branch: Use the class that occurs most
often in the training data. Then the error rate of the rules can easily be determined.
Just count the errors that occur on the training data—that is, the number of
instances that do not have the majority class.
Each attribute generates a different set of rules, one rule for every value of the
attribute. Evaluate the error rate for each attribute’s rule set and choose the best.
It’s that simple! Figure 5.1 shows the algorithm in the form of pseudocode.
To see the 1R method at work, consider the weather data presented in Table
1.2 (we will encounter it many times again when looking at how learning algorithms work). To classify on the final column, play, 1R considers four sets of rules,
one for each attribute. These rules are shown in Table 5.1. An asterisk indicates
that a random choice has been made between two equally likely outcomes. The
number of errors is given for each rule, along with the total number of errors for
the rule set as a whole. 1R chooses the attribute that produces rules with the
smallest number of errors—that is, the first and third rule sets. Arbitrarily breaking
the tie between these two rule sets gives
outlook:sunny    → no
→ yes
         rainy    → yes

For each attribute,
For each value of that attribute, make a rule as follows:
count how often each class appears
find the most frequent class
make the rule assign that class to this attribute-value.
Calculate the error rate of the rules.
Choose the rules with the smallest error rate.

Pseudocode for 1R.

5.1  Inferring Rudimentary Rules   133

Table 5.1 Evaluating the Attributes in the Weather Data












→ no


Total Errors



Overcast→ yes



→ yes



→ no*



→ yes



→ yes



→ no


Normal → yes



→ yes



→ no*





*A random choice was made between two equally likely outcomes.

We noted at the outset that the game for the weather data is unspecified. Oddly
enough, it is apparently played when it is overcast or rainy but not when it is
sunny. Perhaps it’s an indoor pursuit.

5.1.1  Missing Values and Numeric Attributes
Although a rudimentary learning method, 1R does accommodate both missing
values and numeric attributes. It deals with these in simple but effective ways.
Missing is treated as just another attribute value so that, for example, if the
weather data had contained missing values for the outlook attribute, a rule set
formed on outlook would specify four possible class values, one each for sunny,
overcast, and rainy and a fourth for missing.
We can convert numeric attributes into nominal ones using a simple discreti­
zation method. First, sort the training examples according to the values of the
numeric attribute. This produces a sequence of class values. For example, sorting
the numeric version of the weather data (Table 1.3) according to the values of
temperature produces the sequence














Discretization involves partitioning this sequence by placing breakpoints in it.
One possibility is to place breakpoints wherever the class changes, producing the
following eight categories:

134    CHAPTER 5  Algorithms: The Basic Methods

yes | no | yes yes yes | no no | yes yes yes | no | yes yes | no

Choosing breakpoints halfway between the examples on either side places
them at 64.5, 66.5, 70.5, 72, 77.5, 80.5, and 84. However, the two instances
with value 72 cause a problem because they have the same value of temperature
but fall into different classes. The simplest fix is to move the breakpoint at 72 up
one example, to 73.5, producing a mixed partition in which no is the majority
A more serious problem is that this procedure tends to form a large number
of categories. The 1R method will naturally gravitate toward choosing an attribute
that splits into many categories, because this will partition the dataset into many
classes, making it more likely that instances will have the same class as the majority in their partition. In fact, the limiting case is an attribute that has a different
value for each instance—that is, an identification code attribute that pinpoints
instances uniquely—and this will yield a zero error rate on the training set because
each partition contains just one instance. Of course, highly branching attributes
do not usually perform well on test examples; indeed, the identification code
attribute will never predict any examples outside the training set correctly. This
phenomenon is known as overfitting.
For 1R, overfitting is likely to occur whenever an attribute has a large number
of possible values. Consequently, when discretizing a numeric attribute, a rule is
adopted that dictates a minimum number of examples of the majority class in each
partition. Suppose that minimum is set at three. This eliminates all but two of the
preceding partitions. Instead, the partitioning process begins
yes no yes yes | yes. . .

ensuring that there are three occurrences of yes, the majority class, in the first
partition. However, because the next example is also yes, we lose nothing by
including that in the first partition, too. This leads to a new division:
yes no yes yes yes | no no yes yes yes | no yes yes no

where each partition contains at least three instances of the majority class, except
the last one, which will usually have less. Partition boundaries always fall between
examples of different classes.
Whenever adjacent partitions have the same majority class, as do the first two
partitions shown here, they can be merged together without affecting the meaning
of the rule sets. Thus, the final discretization is
yes no yes yes yes no no yes yes yes | no yes yes no

which leads to the rule set
temperature: ≤ 77.5 → yes
              > 77.5 → no

5.1  Inferring Rudimentary Rules   135

The second rule involved an arbitrary choice; as it happens, no was chosen. If
we had chosen yes instead, there would be no need for any breakpoint at all—and
as this example illustrates, it might be better to use the adjacent categories to help
to break ties. In fact, this rule generates five errors on the training set and so is
less effective than the preceding rule for outlook. However, the same procedure
leads to this rule for humidity:
humidity: ≤ 82.5 → yes
           > 82.5 and ≤ 95.5 → no
           > 95.5 → yes

This generates only three errors on the training set and is the best “1-rule” for
the data in Table 1.3.
Finally, if a numeric attribute has missing values, an additional category is
created for them, and the preceding discretization procedure is applied just to the
instances for which the attribute’s value is defined.

5.1.2  Discussion
In a seminal paper titled “Very Simple Classification Rules Perform Well on Most
Commonly Used Datasets” (Holte 1993), a comprehensive study of the performance of the 1R procedure was reported on 16 datasets that machine learning
researchers frequently use to evaluate their algorithms. Throughout, the study
used cross-validation to ensure that the results were representative of what independent test sets would yield. After some experimentation, the minimum number
of examples in each partition of a numeric attribute was set at six, not three as
used for the preceding illustration.
Surprisingly, despite its simplicity 1R did astonishingly—even embarrassingly—well in comparison with state-of-the-art learning methods, and the rules it
produced turned out to be just a few percentage points less accurate, on almost
all of the datasets, than the decision trees produced by a state-of-the-art decision
tree induction scheme. These trees were, in general, considerably larger than 1R’s
rules. Rules that test a single attribute are often a viable alternative to more
complex structures, and this strongly encourages a simplicity-first methodology
in which the baseline performance is established using rudimentary techniques
before progressing to more sophisticated learning methods, which inevitably
generate output that is harder for people to interpret.
The 1R procedure learns a one-level decision tree whose leaves represent the
various different classes. A slightly more expressive technique is to use a different
rule for each class. Each rule is a conjunction of tests, one for each attribute. For
numeric attributes the test checks whether the value lies within a given interval;
for nominal ones it checks whether it is in a certain subset of that attribute’s
values. These two types of tests—intervals and subset—are learned from the training data pertaining to each class. For a numeric attribute, the endpoints of the
interval are the minimum and maximum values that occur in the training data for