<!doctype html>
<html class="no-js" dir="ltr" lang="en-US">
<head>
	<meta charset="UTF-8">
	<meta name="viewport" content="width=1100">

	<title>MADlib</title>

	<script src="https://use.typekit.net/qbv8hok.js"></script>
	<script>try{Typekit.load({ async: true });}catch(e){}</script>

	<link rel="shortcut icon" href="favicon.ico" />

	<link rel='stylesheet' href='style.css' type='text/css' media='all' />

  <script type='text/javascript' src='https://code.jquery.com/jquery-1.10.2.min.js'></script>
  <script type="text/javascript" src="html5lightbox.js"></script>
  <script type='text/javascript' src='master.js'></script>

</head>
<body class="page page-id-25 page-template page-template-default">
	<div class="header">
		<div class="container">
			<a href="index.html" class="logo">
				Home
			</a>
			<div class="nav">
				<div class="menu-primary-navigation-container"><ul id="menu-primary-navigation" class="menu"><li id="menu-item-27" class="menu-item menu-item-type-post_type menu-item-object-page page_item page-item-18 current_page_item menu-item-27"><a href="index.html">Home</a></li>
					<li id="menu-item-28" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-28"><a href="product.html">Product</a></li>
					<li id="menu-item-25" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-25"><a title="Documentation" href="documentation.html">Documentation</a></li>
					<li id="menu-item-24" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-24"><a href="community.html">Community</a></li>
                                        <li class="li-asflinks">
                                            <select id="latest-asflinks" name="latest-asflinks" class="select-asflinks">
                                              <option value="">ASF Links</option>
                                              <option value="https://www.apache.org/">ASF Homepage</option>
                                              <option value="https://www.apache.org/events/current-event.html">Apache Events</option>
                                              <option value="https://www.apache.org/foundation/policies/conduct.html">Code of Conduct</option>
                                              <option value="https://privacy.apache.org/policies/privacy-policy-public.html">Privacy Policy</option>
                                              <option value="https://www.apache.org/security/">Security</option>
                                              <option value="https://www.apache.org/foundation/sponsorship.html">Sponsorship</option>
                                              <option value="https://www.apache.org/foundation/thanks.html">Thanks</option>
                                            </select>
                                        </li>
					<li id="menu-item-26" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-26 nav-button last"><a href="download.html">Download</a></li>
					</ul>
				</div>
			</div>
		</div>
	</div>
	<div class="primary-content">
	<div class="container section-head">
		<div class="section-name">
			<h1 class="h2">Documentation</h1>
		</div>
			</div>
			<script type='text/javascript'>
jQuery(document).ready(function() {
    $('.section-name h1').html("Documentation &#038; Resources");
});
</script>

<div class="container section">
<div class="documentation-posts">
<div class="row post">
<div class="span4"><img class="wp-post-image" alt="" src="_media/icons/document.png" /></div>
<div class="span8">
<h3><a class="pointer point-right" href="docs/latest/index.html">Latest User Guide</a></h3>
<p class="body">The primary documentation reference material providing detailed information on the functions and algorithms within MADlib as well as background theory and references into the literature.</p>

<div class="select-documentation pointer point-down"><select id="latest-documentation" name="latest-documentation" size="1"><option value="">Older Documentation</option>
<option value="docs/v1.20.0/index.html">MADlib v1.20.0</option>
<option value="docs/v1.19.0/index.html">MADlib v1.19.0</option>
<option value="docs/v1.18.0/index.html">MADlib v1.18.0</option>
<option value="docs/v1.17.0/index.html">MADlib v1.17.0</option>
<option value="docs/v1.16/index.html">MADlib v1.16</option>
<option value="docs/v1.15.1/index.html">MADlib v1.15.1</option>
<option value="docs/v1.15/index.html">MADlib v1.15</option>
<option value="docs/v1.14/index.html">MADlib v1.14</option>
<option value="docs/v1.13/index.html">MADlib v1.13</option>
<option value="docs/v1.12/index.html">MADlib v1.12</option>
<option value="docs/v1.11/index.html">MADlib v1.11</option>
<option value="docs/v1.10/index.html">MADlib v1.10</option>
<option value="docs/v1.9.1/index.html">MADlib v1.9.1</option>
<option value="docs/v1.9/index.html">MADlib v1.9</option>
<option value="docs/v1.8/index.html">MADlib v1.8</option>
<option value="docs/v1.7.1/index.html">MADlib v1.7.1</option>
<option value="docs/v1.7/index.html">MADlib v1.7</option>
<option value="docs/v1.6/index.html">MADlib v1.6</option>
<option value="docs/v1.5/index.html">MADlib v1.5</option>
<option value="docs/v1.4/index.html">MADlib v1.4</option>
<option value="docs/v1.3/index.html">MADlib v1.3</option>
<option value="docs/v1.2/index.html">MADlib v1.2</option>
<option value="docs/v1.1/index.html">MADlib v1.1</option>
<option value="docs/v1.0/index.html">MADlib v1.0</option>
</select></div>
</div>
</div>
<div class="row post">
<div class="span4"><img class="wp-post-image" alt="" src="_media/icons/document.png" /></div>
<div class="span8">
<h3><a class="pointer point-right" href="https://cwiki.apache.org/confluence/display/MADLIB/Installation+Guide">Installation Guide</a></h3>
<p class="body">Information on initial installation and deployment of MADlib into a database instance.</p>

</div>
</div>
<div class="row post">
<div class="span4"><img class="wp-post-image" alt="" src="_media/icons/document.png" /></div>
<div class="span8">
<h3><a class="pointer point-right" href="https://cwiki.apache.org/confluence/display/MADLIB/Quick+Start+Guide+for+Users">Quick Start Guide for Users</a></h3>
<p class="body">Introduction to themes and concepts in MADlib. The guide walks the user through an initial data load, training a model, inspecting a model, and scoring a model.</p>

</div>
</div>
<div class="row post">
<div class="span4"><img class="wp-post-image" alt="" src="_media/icons/document.png" /></div>
<div class="span8">
<h3><a class="pointer point-right" href="https://cwiki.apache.org/confluence/display/MADLIB/Quick+Start+Guide+for+Developers">Quick Start Guide for Developers</a></h3>
<p class="body">For developers who are interested in contributing to MADlib.  Includes instructions for an available Docker image with necessary dependencies to compile and test MADlib.</p>

</div>
</div>
<div class="row post">
<div class="span4"><img class="wp-post-image" alt="" src="_media/icons/document.png" /></div>
<div class="span8">
<h3><a class="pointer point-right" href="https://github.com/apache/madlib-site/tree/asf-site/community-artifacts">Jupyter Notebooks for Getting Started</a></h3>
<p class="body">Includes many commonly used algorithms by data scientists.</p>

</div>
</div>
<div class="row post">
<div class="span4"><img class="wp-post-image" alt="" src="_media/icons/community-portal.png" /></div>
<div class="span8">
<h3><a class="pointer point-right" href="community.html">Community Portal</a></h3>
<p class="body">Additional material for individuals looking to contribute to the project is available on our community portal.</p>
</div>
</div>
</div>
</div>
<div class="container section use-case-posts">
<h2>Example Use Cases</h2>
<div class="row"><div class="post-203 post type-post status-publish format-standard hentry category-use-case span4 simple-box ">
	<a href="docs/latest/group__grp__linreg.html#examples">
		<h4 class="title pointer point-right">Linear Regression</h4>
		<p class="body">
			Linear regression is used to model the linear relationship of a scalar dependent variable to one or more explanatory independent variables.
					</p>
	</a>
</div>
<div class="post-218 post type-post status-publish format-standard hentry category-use-case span4 simple-box ">
	<a href="docs/latest/group__grp__lda.html#examples">
		<h4 class="title pointer point-right">Latent Dirichlet Allocation</h4>
		<p class="body">
			Latent Dirichlet Allocation is a topic modeling function used to identify recurring themes in a large document corpus.
					</p>
	</a>
</div>
<div class="post-201 post type-post status-publish format-standard hentry category-use-case span4 simple-box ">
	<a href="docs/latest/group__grp__summary.html#examples">
		<h4 class="title pointer point-right">Summary</h4>
		<p class="body">
			The summary function provides summary statistics for any data table.  These statistics include: number of distinct values, number of missing values, mean, variance, min, max, most frequent values, quantiles, etc.
					</p>
	</a>
</div>
<div class="post-206 post type-post status-publish format-standard hentry category-use-case span4 simple-box ">
	<a href="docs/latest/group__grp__logreg.html#examples">
		<h4 class="title pointer point-right">Logistic Regression</h4>
		<p class="body">
			Logistic regression is used to predict a binary outcome of a dependent variable from one or more explanatory independent variables.
					</p>
	</a>
</div>
<div class="post-208 post type-post status-publish format-standard hentry category-use-case span4 simple-box">
	<a href="docs/latest/group__grp__elasticnet.html#examples">
		<h4 class="title pointer point-right">Elastic Net Regularization</h4>
		<p class="body">
			Elastic Net regularization is a technique that can be applied to either linear or logistic regression to build a more robust model, in the event of large numbers of explanatory independent variables.
					</p>
	</a>
</div>
<div class="post-210 post type-post status-publish format-standard hentry category-use-case span4 simple-box ">
	<a href="docs/latest/group__grp__pca__train.html#examples">
		<h4 class="title pointer point-right">Principal Component Analysis</h4>
		<p class="body">
			Pricipal Component Analysis is a dimensional reduction technique that can be used to transform a high dimensional space into a lower dimensional space.
					</p>
	</a>
</div>
<div class="post-213 post type-post status-publish format-standard hentry category-use-case span4 simple-box ">
	<a href="docs/latest/group__grp__assoc__rules.html#examples">
		<h4 class="title pointer point-right">Apriori</h4>
		<p class="body">
			Apriori is a technique for evaluating frequent item-sets, which allows analysis of what events tend to occur together.  For example, which items do customers frequently purchase together in a single transaction?
					</p>
	</a>
</div>
<div class="post-216 post type-post status-publish format-standard hentry category-use-case span4 simple-box ">
	<a href="docs/latest/group__grp__kmeans.html#examples">
		<h4 class="title pointer point-right">k-Means</h4>
		<p class="body">
			k-Means is a clustering method used to identify regions of similarity within a dataset.   It can be used for many types of analysis including customer segmentation.
					</p>
	</a>
</div>
<div class="post-216 post type-post status-publish format-standard hentry category-use-case span4 simple-box ">
	<a href="docs/latest/group__grp__sssp.html#examples">
		<h4 class="title pointer point-right">Shortest Path in a Graph</h4>
		<p class="body">
			Finds a path from a source vertex to every other vertex in the graph.   Example uses include vehicle routing/navigation, degrees of separation in a social network and minimum delay path in a telecommunications network.
					</p>
	</a>
</div>
</div>
</div>			</div>
	<div class="footer">
	  <div class="container">
		 	<img src='https://apache.org/images/asf-logo.gif' width="310" height="80"/>
		  <br/>
		  <br/>
	    <p>
	      Copyright &copy; <script> var d = new Date();document.write(d.getFullYear());</script> <a href='https://www.apache.org/'>The Apache Software Foundation</a>, Licensed under the <a href='https://www.apache.org/licenses/LICENSE-2.0'>Apache License, Version 2.0.</a>
	      <br>
	      Apache, Apache MADlib, the Apache feather and the MADlib logo are trademarks of The Apache Software Foundation
	    </p>
	  </div>
	</div>
</body>
</html>
