bayesian_bootstrap.bootstrap module
1085 | 1086 | 1087 | 1088 |
1089 |
1327 |
1328 |
1329 |
1330 | import numpy as np 1090 | from copy import deepcopy 1091 | 1092 | def mean(X, n_replications): 1093 | """Simulate the posterior distribution of the mean. 1094 | 1095 | Parameter X: The observed data (array like) 1096 | 1097 | Parameter n_replications: The number of bootstrap replications to perform (positive integer) 1098 | 1099 | Returns: Samples from the posterior 1100 | """ 1101 | samples = [] 1102 | weights = np.random.dirichlet([1]*len(X), n_replications) 1103 | for w in weights: 1104 | samples.append(np.dot(X, w)) 1105 | return samples 1106 | 1107 | def var(X, n_replications): 1108 | """Simulate the posterior distribution of the variance. 1109 | 1110 | Parameter X: The observed data (array like) 1111 | 1112 | Parameter n_replications: The number of bootstrap replications to perform (positive integer) 1113 | 1114 | Returns: Samples from the posterior 1115 | """ 1116 | samples = [] 1117 | weights = np.random.dirichlet([1]*len(X), n_replications) 1118 | for w in weights: 1119 | samples.append(np.dot([x ** 2 for x in X], w) - np.dot(X, w) ** 2) 1120 | return samples 1121 | 1122 | def covar(X, Y, n_replications): 1123 | """Simulate the posterior distribution of the covariance. 1124 | 1125 | Parameter X: The observed data, first variable (array like) 1126 | 1127 | Parameter Y: The observed data, second (array like) 1128 | 1129 | Parameter n_replications: The number of bootstrap replications to perform (positive integer) 1130 | 1131 | Returns: Samples from the posterior 1132 | """ 1133 | samples = [] 1134 | weights = np.random.dirichlet([1]*len(X), n_replications) 1135 | for w in weights: 1136 | X_mean = np.dot(X, w) 1137 | Y_mean = np.dot(Y, w) 1138 | samples.append(np.dot(w, (X - X_mean)*(Y - Y_mean))) 1139 | return samples 1140 | 1141 | def bayesian_bootstrap(X, statistic, n_replications, resample_size,low_mem=False): 1142 | """Simulate the posterior distribution of the given statistic. 1143 | 1144 | Parameter X: The observed data (array like) 1145 | 1146 | Parameter statistic: A function of the data to use in simulation (Function mapping array-like to number) 1147 | 1148 | Parameter n_replications: The number of bootstrap replications to perform (positive integer) 1149 | 1150 | Parameter resample_size: The size of the dataset in each replication 1151 | 1152 | Parameter low_mem(bool): Generate the weights for each iteration lazily instead of in a single batch. Will use 1153 | less memory, but will run slower as a result. 1154 | 1155 | Returns: Samples from the posterior 1156 | """ 1157 | if isinstance(X, list): 1158 | X = np.array(X) 1159 | samples = [] 1160 | if low_mem: 1161 | weights = (np.random.dirichlet([1] * len(X)) for _ in range(n_replications)) 1162 | else: 1163 | weights = np.random.dirichlet([1] * len(X), n_replications) 1164 | for w in weights: 1165 | sample_index = np.random.choice(range(len(X)), p=w, size=resample_size) 1166 | resample_X = X[sample_index] 1167 | s = statistic(resample_X) 1168 | samples.append(s) 1169 | return samples 1170 | 1171 | def bayesian_bootstrap_regression(X, y, statistic, n_replications, resample_size,low_mem=False): 1172 | """Simulate the posterior distribution of a statistic that uses dependent and independent variables. 1173 | 1174 | Parameter X: The observed data, independent variables (matrix like) 1175 | 1176 | Parameter y: The observed data, dependent variable (array like) 1177 | 1178 | Parameter statistic: A function of the data to use in simulation (Function mapping array-like to number) 1179 | 1180 | Parameter n_replications: The number of bootstrap replications to perform (positive integer) 1181 | 1182 | Parameter resample_size: The size of the dataset in each replication 1183 | 1184 | Parameter low_mem(bool): Use looping instead of generating all the dirichlet, use if program use too much memory 1185 | 1186 | Returns: Samples from the posterior 1187 | """ 1188 | samples = [] 1189 | X_arr = np.array(X) 1190 | y_arr = np.array(y) 1191 | if low_mem: 1192 | weights = (np.random.dirichlet([1] * len(X)) for _ in range(n_replications)) 1193 | else: 1194 | weights = np.random.dirichlet([1] * len(X), n_replications) 1195 | for w in weights: 1196 | resample_i = np.random.choice(range(len(X_arr)), p=w, size=resample_size) 1197 | resample_X = X_arr[resample_i] 1198 | resample_y = y_arr[resample_i] 1199 | s = statistic(resample_X, resample_y) 1200 | samples.append(s) 1201 | 1202 | return samples 1203 | 1204 | class BayesianBootstrapBagging(object): 1205 | """A bootstrap aggregating model using the bayesian bootstrap. Similar to scikit-learn's BaggingRegressor.""" 1206 | def __init__(self, base_learner, n_replications, resample_size, low_mem=False): 1207 | """Initialize the base learners of the ensemble. 1208 | 1209 | Parameter base_learner: A scikit-learn like estimator. This object should implement a fit() and predict() 1210 | method. 1211 | 1212 | Parameter n_replications: The number of bootstrap replications to perform (positive integer) 1213 | 1214 | Parameter resample_size: The size of the dataset in each replication 1215 | 1216 | Parameter low_mem(bool): Generate the weights for each iteration lazily instead of in a single batch. Will use 1217 | less memory, but will run slower as a result. 1218 | """ 1219 | self.base_learner = base_learner 1220 | self.n_replications = n_replications 1221 | self.resample_size = resample_size 1222 | self.memo = low_mem 1223 | 1224 | def fit(self, X, y): 1225 | """Fit the base learners of the ensemble on a dataset. 1226 | 1227 | Parameter X: The observed data, independent variables (matrix like) 1228 | 1229 | Parameter y: The observed data, dependent variable (array like) 1230 | 1231 | Returns: Fitted model 1232 | """ 1233 | self.base_models_ = bayesian_bootstrap_regression(X, 1234 | y, 1235 | lambda X, y: deepcopy(self.base_learner).fit(X, y), 1236 | self.n_replications, 1237 | self.resample_size, 1238 | low_mem=self.memo) 1239 | return self 1240 | 1241 | def predict(self, X): 1242 | """Make average predictions for a collection of observations. 1243 | 1244 | Parameter X: The observed data, independent variables (matrix like) 1245 | 1246 | Returns: The predicted dependent variable values (array like) 1247 | """ 1248 | y_posterior_samples = self.predict_posterior_samples(X) 1249 | return np.array([np.mean(r) for r in y_posterior_samples]) 1250 | 1251 | def predict_posterior_samples(self, X): 1252 | """Simulate posterior samples for a collection of observations. 1253 | 1254 | Parameter X: The observed data, independent variables (matrix like) 1255 | 1256 | Returns: The simulated posterior mean (matrix like) 1257 | """ 1258 | # Return a X_r x self.n_replications matrix 1259 | y_posterior_samples = np.zeros((len(X), self.n_replications)) 1260 | for i, m in enumerate(self.base_models_): 1261 | y_posterior_samples[:,i] = m.predict(X) 1262 | return y_posterior_samples 1263 | 1264 | def predict_central_interval(self, X, alpha=0.05): 1265 | """The equal-tailed interval prediction containing a (1-alpha) fraction of the posterior samples. 1266 | 1267 | Parameter X: The observed data, independent variables (matrix like) 1268 | 1269 | Parameter alpha: The total size of the tails (Float between 0 and 1) 1270 | 1271 | Returns: Left and right interval bounds for each input (matrix like) 1272 | """ 1273 | y_posterior_samples = self.predict_posterior_samples(X) 1274 | return np.array([central_credible_interval(r, alpha=alpha) for r in y_posterior_samples]) 1275 | 1276 | def predict_highest_density_interval(self, X, alpha=0.05): 1277 | """The highest density interval prediction containing a (1-alpha) fraction of the posterior samples. 1278 | 1279 | Parameter X: The observed data, independent variables (matrix like) 1280 | 1281 | Parameter alpha: The total size of the tails (Float between 0 and 1) 1282 | 1283 | Returns: Left and right interval bounds for each input (matrix like): 1284 | """ 1285 | y_posterior_samples = self.predict_posterior_samples(X) 1286 | return np.array([highest_density_interval(r, alpha=alpha) for r in y_posterior_samples]) 1287 | 1288 | def central_credible_interval(samples, alpha=0.05): 1289 | """The equal-tailed interval containing a (1-alpha) fraction of the posterior samples. 1290 | 1291 | Parameter samples: The posterior samples (array like) 1292 | 1293 | Parameter alpha: The total size of the tails (Float between 0 and 1) 1294 | 1295 | Returns: Left and right interval bounds (tuple) 1296 | """ 1297 | tail_size = int(round(len(samples)*(alpha/2))) 1298 | samples_sorted = sorted(samples) 1299 | return samples_sorted[tail_size],samples_sorted[-tail_size-1] 1300 | 1301 | def highest_density_interval(samples, alpha=0.05): 1302 | """The highest-density interval containing a (1-alpha) fraction of the posterior samples. 1303 | 1304 | Parameter samples: The posterior samples (array like) 1305 | 1306 | Parameter alpha: The total size of the tails (Float between 0 and 1) 1307 | 1308 | Returns: Left and right interval bounds (tuple) 1309 | """ 1310 | samples_sorted = sorted(samples) 1311 | window_size = int(len(samples) - round(len(samples)*alpha)) 1312 | smallest_window = (None, None) 1313 | smallest_window_length = float('inf') 1314 | for i in range(len(samples_sorted) - window_size): 1315 | window = samples_sorted[i+window_size-1], samples_sorted[i] 1316 | window_length = samples_sorted[i+window_size-1] - samples_sorted[i] 1317 | if window_length < smallest_window_length: 1318 | smallest_window_length = window_length 1319 | smallest_window = window 1320 | return smallest_window[1], smallest_window[0] 1321 | 1322 | def _bootstrap_replicate(X): 1323 | random_points = [0] + sorted(np.random.uniform(0, 1, len(X) - 1)) + [1] 1324 | gaps = [r - l for l, r in zip(random_points[:-1], random_points[1:])] 1325 | return gaps 1326 |
Functions
1335 | 1336 |
1337 |
1352 |
1390 |
1391 |
1392 |
1338 |
1340 |
1341 |
1342 |
1343 |
1344 | def bayesian_bootstrap(
X, statistic, n_replications, resample_size, low_mem=False)
1339 |Simulate the posterior distribution of the given statistic.
1345 |Parameter X: The observed data (array like)
1346 |Parameter statistic: A function of the data to use in simulation (Function mapping array-like to number)
1347 |Parameter n_replications: The number of bootstrap replications to perform (positive integer)
1348 |Parameter resample_size: The size of the dataset in each replication
1349 |Parameter low_mem(bool): Generate the weights for each iteration lazily instead of in a single batch. Will use 1350 | less memory, but will run slower as a result.
1351 |Returns: Samples from the posterior
1353 |
1354 |
1388 |
1389 |
1355 |
1385 |
1386 |
1387 | def bayesian_bootstrap(X, statistic, n_replications, resample_size,low_mem=False): 1356 | """Simulate the posterior distribution of the given statistic. 1357 | 1358 | Parameter X: The observed data (array like) 1359 | 1360 | Parameter statistic: A function of the data to use in simulation (Function mapping array-like to number) 1361 | 1362 | Parameter n_replications: The number of bootstrap replications to perform (positive integer) 1363 | 1364 | Parameter resample_size: The size of the dataset in each replication 1365 | 1366 | Parameter low_mem(bool): Generate the weights for each iteration lazily instead of in a single batch. Will use 1367 | less memory, but will run slower as a result. 1368 | 1369 | Returns: Samples from the posterior 1370 | """ 1371 | if isinstance(X, list): 1372 | X = np.array(X) 1373 | samples = [] 1374 | if low_mem: 1375 | weights = (np.random.dirichlet([1] * len(X)) for _ in range(n_replications)) 1376 | else: 1377 | weights = np.random.dirichlet([1] * len(X), n_replications) 1378 | for w in weights: 1379 | sample_index = np.random.choice(range(len(X)), p=w, size=resample_size) 1380 | resample_X = X[sample_index] 1381 | s = statistic(resample_X) 1382 | samples.append(s) 1383 | return samples 1384 |
1393 |
1408 |
1449 |
1450 |
1451 |
1394 |
1396 |
1397 |
1398 |
1399 |
1400 | def bayesian_bootstrap_regression(
X, y, statistic, n_replications, resample_size, low_mem=False)
1395 |Simulate the posterior distribution of a statistic that uses dependent and independent variables.
1401 |Parameter X: The observed data, independent variables (matrix like)
1402 |Parameter y: The observed data, dependent variable (array like)
1403 |Parameter statistic: A function of the data to use in simulation (Function mapping array-like to number)
1404 |Parameter n_replications: The number of bootstrap replications to perform (positive integer)
1405 |Parameter resample_size: The size of the dataset in each replication
1406 |Parameter low_mem(bool): Use looping instead of generating all the dirichlet, use if program use too much memory
1407 |Returns: Samples from the posterior
1409 |
1410 |
1447 |
1448 |
1411 |
1444 |
1445 |
1446 | def bayesian_bootstrap_regression(X, y, statistic, n_replications, resample_size,low_mem=False): 1412 | """Simulate the posterior distribution of a statistic that uses dependent and independent variables. 1413 | 1414 | Parameter X: The observed data, independent variables (matrix like) 1415 | 1416 | Parameter y: The observed data, dependent variable (array like) 1417 | 1418 | Parameter statistic: A function of the data to use in simulation (Function mapping array-like to number) 1419 | 1420 | Parameter n_replications: The number of bootstrap replications to perform (positive integer) 1421 | 1422 | Parameter resample_size: The size of the dataset in each replication 1423 | 1424 | Parameter low_mem(bool): Use looping instead of generating all the dirichlet, use if program use too much memory 1425 | 1426 | Returns: Samples from the posterior 1427 | """ 1428 | samples = [] 1429 | X_arr = np.array(X) 1430 | y_arr = np.array(y) 1431 | if low_mem: 1432 | weights = (np.random.dirichlet([1] * len(X)) for _ in range(n_replications)) 1433 | else: 1434 | weights = np.random.dirichlet([1] * len(X), n_replications) 1435 | for w in weights: 1436 | resample_i = np.random.choice(range(len(X_arr)), p=w, size=resample_size) 1437 | resample_X = X_arr[resample_i] 1438 | resample_y = y_arr[resample_i] 1439 | s = statistic(resample_X, resample_y) 1440 | samples.append(s) 1441 | 1442 | return samples 1443 |
1452 |
1463 |
1484 |
1485 |
1486 |
1453 |
1455 |
1456 |
1457 |
1458 |
1459 | def central_credible_interval(
samples, alpha=0.05)
1454 |The equal-tailed interval containing a (1-alpha) fraction of the posterior samples.
1460 |Parameter samples: The posterior samples (array like)
1461 |Parameter alpha: The total size of the tails (Float between 0 and 1)
1462 |Returns: Left and right interval bounds (tuple)
1464 |
1465 |
1482 |
1483 |
1466 |
1479 |
1480 |
1481 | def central_credible_interval(samples, alpha=0.05): 1467 | """The equal-tailed interval containing a (1-alpha) fraction of the posterior samples. 1468 | 1469 | Parameter samples: The posterior samples (array like) 1470 | 1471 | Parameter alpha: The total size of the tails (Float between 0 and 1) 1472 | 1473 | Returns: Left and right interval bounds (tuple) 1474 | """ 1475 | tail_size = int(round(len(samples)*(alpha/2))) 1476 | samples_sorted = sorted(samples) 1477 | return samples_sorted[tail_size],samples_sorted[-tail_size-1] 1478 |
1487 |
1499 |
1526 |
1527 |
1528 |
1488 |
1490 |
1491 |
1492 |
1493 |
1494 | def covar(
X, Y, n_replications)
1489 |Simulate the posterior distribution of the covariance.
1495 |Parameter X: The observed data, first variable (array like)
1496 |Parameter Y: The observed data, second (array like)
1497 |Parameter n_replications: The number of bootstrap replications to perform (positive integer)
1498 |Returns: Samples from the posterior
1500 |
1501 |
1524 |
1525 |
1502 |
1521 |
1522 |
1523 | def covar(X, Y, n_replications): 1503 | """Simulate the posterior distribution of the covariance. 1504 | 1505 | Parameter X: The observed data, first variable (array like) 1506 | 1507 | Parameter Y: The observed data, second (array like) 1508 | 1509 | Parameter n_replications: The number of bootstrap replications to perform (positive integer) 1510 | 1511 | Returns: Samples from the posterior 1512 | """ 1513 | samples = [] 1514 | weights = np.random.dirichlet([1]*len(X), n_replications) 1515 | for w in weights: 1516 | X_mean = np.dot(X, w) 1517 | Y_mean = np.dot(Y, w) 1518 | samples.append(np.dot(w, (X - X_mean)*(Y - Y_mean))) 1519 | return samples 1520 |
1529 |
1540 |
1569 |
1570 |
1571 |
1530 |
1532 |
1533 |
1534 |
1535 |
1536 | def highest_density_interval(
samples, alpha=0.05)
1531 |The highest-density interval containing a (1-alpha) fraction of the posterior samples.
1537 |Parameter samples: The posterior samples (array like)
1538 |Parameter alpha: The total size of the tails (Float between 0 and 1)
1539 |Returns: Left and right interval bounds (tuple)
1541 |
1542 |
1567 |
1568 |
1543 |
1564 |
1565 |
1566 | def highest_density_interval(samples, alpha=0.05): 1544 | """The highest-density interval containing a (1-alpha) fraction of the posterior samples. 1545 | 1546 | Parameter samples: The posterior samples (array like) 1547 | 1548 | Parameter alpha: The total size of the tails (Float between 0 and 1) 1549 | 1550 | Returns: Left and right interval bounds (tuple) 1551 | """ 1552 | samples_sorted = sorted(samples) 1553 | window_size = int(len(samples) - round(len(samples)*alpha)) 1554 | smallest_window = (None, None) 1555 | smallest_window_length = float('inf') 1556 | for i in range(len(samples_sorted) - window_size): 1557 | window = samples_sorted[i+window_size-1], samples_sorted[i] 1558 | window_length = samples_sorted[i+window_size-1] - samples_sorted[i] 1559 | if window_length < smallest_window_length: 1560 | smallest_window_length = window_length 1561 | smallest_window = window 1562 | return smallest_window[1], smallest_window[0] 1563 |
1572 |
1583 |
1606 |
1607 |
1608 |
1573 |
1575 |
1576 |
1577 |
1578 |
1579 | def mean(
X, n_replications)
1574 |Simulate the posterior distribution of the mean.
1580 |Parameter X: The observed data (array like)
1581 |Parameter n_replications: The number of bootstrap replications to perform (positive integer)
1582 |Returns: Samples from the posterior
1584 |
1585 |
1604 |
1605 |
1586 |
1601 |
1602 |
1603 | def mean(X, n_replications): 1587 | """Simulate the posterior distribution of the mean. 1588 | 1589 | Parameter X: The observed data (array like) 1590 | 1591 | Parameter n_replications: The number of bootstrap replications to perform (positive integer) 1592 | 1593 | Returns: Samples from the posterior 1594 | """ 1595 | samples = [] 1596 | weights = np.random.dirichlet([1]*len(X), n_replications) 1597 | for w in weights: 1598 | samples.append(np.dot(X, w)) 1599 | return samples 1600 |
1609 |
1620 |
1643 |
1644 |
1645 |
1610 |
1612 |
1613 |
1614 |
1615 |
1616 | def var(
X, n_replications)
1611 |Simulate the posterior distribution of the variance.
1617 |Parameter X: The observed data (array like)
1618 |Parameter n_replications: The number of bootstrap replications to perform (positive integer)
1619 |Returns: Samples from the posterior
1621 |
1622 |
1641 |
1642 |
1623 |
1638 |
1639 |
1640 | def var(X, n_replications): 1624 | """Simulate the posterior distribution of the variance. 1625 | 1626 | Parameter X: The observed data (array like) 1627 | 1628 | Parameter n_replications: The number of bootstrap replications to perform (positive integer) 1629 | 1630 | Returns: Samples from the posterior 1631 | """ 1632 | samples = [] 1633 | weights = np.random.dirichlet([1]*len(X), n_replications) 1634 | for w in weights: 1635 | samples.append(np.dot([x ** 2 for x in X], w) - np.dot(X, w) ** 2) 1636 | return samples 1637 |
Classes
1646 | 1647 |
1648 |
1652 |
1993 |
1994 | class BayesianBootstrapBagging
1649 | 1650 | 1651 |A bootstrap aggregating model using the bayesian bootstrap. Similar to scikit-learn's BaggingRegressor.
1653 |
1654 |
1742 |
1743 |
1744 |
1655 |
1739 |
1740 |
1741 | class BayesianBootstrapBagging(object): 1656 | """A bootstrap aggregating model using the bayesian bootstrap. Similar to scikit-learn's BaggingRegressor.""" 1657 | def __init__(self, base_learner, n_replications, resample_size, low_mem=False): 1658 | """Initialize the base learners of the ensemble. 1659 | 1660 | Parameter base_learner: A scikit-learn like estimator. This object should implement a fit() and predict() 1661 | method. 1662 | 1663 | Parameter n_replications: The number of bootstrap replications to perform (positive integer) 1664 | 1665 | Parameter resample_size: The size of the dataset in each replication 1666 | 1667 | Parameter low_mem(bool): Generate the weights for each iteration lazily instead of in a single batch. Will use 1668 | less memory, but will run slower as a result. 1669 | """ 1670 | self.base_learner = base_learner 1671 | self.n_replications = n_replications 1672 | self.resample_size = resample_size 1673 | self.memo = low_mem 1674 | 1675 | def fit(self, X, y): 1676 | """Fit the base learners of the ensemble on a dataset. 1677 | 1678 | Parameter X: The observed data, independent variables (matrix like) 1679 | 1680 | Parameter y: The observed data, dependent variable (array like) 1681 | 1682 | Returns: Fitted model 1683 | """ 1684 | self.base_models_ = bayesian_bootstrap_regression(X, 1685 | y, 1686 | lambda X, y: deepcopy(self.base_learner).fit(X, y), 1687 | self.n_replications, 1688 | self.resample_size, 1689 | low_mem=self.memo) 1690 | return self 1691 | 1692 | def predict(self, X): 1693 | """Make average predictions for a collection of observations. 1694 | 1695 | Parameter X: The observed data, independent variables (matrix like) 1696 | 1697 | Returns: The predicted dependent variable values (array like) 1698 | """ 1699 | y_posterior_samples = self.predict_posterior_samples(X) 1700 | return np.array([np.mean(r) for r in y_posterior_samples]) 1701 | 1702 | def predict_posterior_samples(self, X): 1703 | """Simulate posterior samples for a collection of observations. 1704 | 1705 | Parameter X: The observed data, independent variables (matrix like) 1706 | 1707 | Returns: The simulated posterior mean (matrix like) 1708 | """ 1709 | # Return a X_r x self.n_replications matrix 1710 | y_posterior_samples = np.zeros((len(X), self.n_replications)) 1711 | for i, m in enumerate(self.base_models_): 1712 | y_posterior_samples[:,i] = m.predict(X) 1713 | return y_posterior_samples 1714 | 1715 | def predict_central_interval(self, X, alpha=0.05): 1716 | """The equal-tailed interval prediction containing a (1-alpha) fraction of the posterior samples. 1717 | 1718 | Parameter X: The observed data, independent variables (matrix like) 1719 | 1720 | Parameter alpha: The total size of the tails (Float between 0 and 1) 1721 | 1722 | Returns: Left and right interval bounds for each input (matrix like) 1723 | """ 1724 | y_posterior_samples = self.predict_posterior_samples(X) 1725 | return np.array([central_credible_interval(r, alpha=alpha) for r in y_posterior_samples]) 1726 | 1727 | def predict_highest_density_interval(self, X, alpha=0.05): 1728 | """The highest density interval prediction containing a (1-alpha) fraction of the posterior samples. 1729 | 1730 | Parameter X: The observed data, independent variables (matrix like) 1731 | 1732 | Parameter alpha: The total size of the tails (Float between 0 and 1) 1733 | 1734 | Returns: Left and right interval bounds for each input (matrix like): 1735 | """ 1736 | y_posterior_samples = self.predict_posterior_samples(X) 1737 | return np.array([highest_density_interval(r, alpha=alpha) for r in y_posterior_samples]) 1738 |
1745 |
1992 | Ancestors (in MRO)
1746 |-
1747 |
- BayesianBootstrapBagging 1748 |
- builtins.object 1749 |
Static methods
1751 | 1752 |
1753 |
1767 |
1790 |
1791 |
1792 |
1754 |
1756 |
1757 |
1758 |
1759 |
1760 | def __init__(
self, base_learner, n_replications, resample_size, low_mem=False)
1755 |Initialize the base learners of the ensemble.
1761 |Parameter base_learner: A scikit-learn like estimator. This object should implement a fit() and predict() 1762 | method.
1763 |Parameter n_replications: The number of bootstrap replications to perform (positive integer)
1764 |Parameter resample_size: The size of the dataset in each replication
1765 |Parameter low_mem(bool): Generate the weights for each iteration lazily instead of in a single batch. Will use 1766 | less memory, but will run slower as a result.
1768 |
1769 |
1788 |
1789 |
1770 |
1785 |
1786 |
1787 | def __init__(self, base_learner, n_replications, resample_size, low_mem=False): 1771 | """Initialize the base learners of the ensemble. 1772 | Parameter base_learner: A scikit-learn like estimator. This object should implement a fit() and predict() 1773 | method. 1774 | Parameter n_replications: The number of bootstrap replications to perform (positive integer) 1775 | Parameter resample_size: The size of the dataset in each replication 1776 | 1777 | Parameter low_mem(bool): Generate the weights for each iteration lazily instead of in a single batch. Will use 1778 | less memory, but will run slower as a result. 1779 | """ 1780 | self.base_learner = base_learner 1781 | self.n_replications = n_replications 1782 | self.resample_size = resample_size 1783 | self.memo = low_mem 1784 |
1793 |
1804 |
1826 |
1827 |
1828 |
1794 |
1796 |
1797 |
1798 |
1799 |
1800 | def fit(
self, X, y)
1795 |Fit the base learners of the ensemble on a dataset.
1801 |Parameter X: The observed data, independent variables (matrix like)
1802 |Parameter y: The observed data, dependent variable (array like)
1803 |Returns: Fitted model
1805 |
1806 |
1824 |
1825 |
1807 |
1821 |
1822 |
1823 | def fit(self, X, y): 1808 | """Fit the base learners of the ensemble on a dataset. 1809 | Parameter X: The observed data, independent variables (matrix like) 1810 | Parameter y: The observed data, dependent variable (array like) 1811 | Returns: Fitted model 1812 | """ 1813 | self.base_models_ = bayesian_bootstrap_regression(X, 1814 | y, 1815 | lambda X, y: deepcopy(self.base_learner).fit(X, y), 1816 | self.n_replications, 1817 | self.resample_size, 1818 | low_mem=self.memo) 1819 | return self 1820 |
1829 |
1839 |
1855 |
1856 |
1857 |
1830 |
1832 |
1833 |
1834 |
1835 |
1836 | def predict(
self, X)
1831 |Make average predictions for a collection of observations.
1837 |Parameter X: The observed data, independent variables (matrix like)
1838 |Returns: The predicted dependent variable values (array like)
1840 |
1841 |
1853 |
1854 |
1842 |
1850 |
1851 |
1852 | def predict(self, X): 1843 | """Make average predictions for a collection of observations. 1844 | Parameter X: The observed data, independent variables (matrix like) 1845 | Returns: The predicted dependent variable values (array like) 1846 | """ 1847 | y_posterior_samples = self.predict_posterior_samples(X) 1848 | return np.array([np.mean(r) for r in y_posterior_samples]) 1849 |
1858 |
1869 |
1886 |
1887 |
1888 |
1859 |
1861 |
1862 |
1863 |
1864 |
1865 | def predict_central_interval(
self, X, alpha=0.05)
1860 |The equal-tailed interval prediction containing a (1-alpha) fraction of the posterior samples.
1866 |Parameter X: The observed data, independent variables (matrix like)
1867 |Parameter alpha: The total size of the tails (Float between 0 and 1)
1868 |Returns: Left and right interval bounds for each input (matrix like)
1870 |
1871 |
1884 |
1885 |
1872 |
1881 |
1882 |
1883 | def predict_central_interval(self, X, alpha=0.05): 1873 | """The equal-tailed interval prediction containing a (1-alpha) fraction of the posterior samples. 1874 | Parameter X: The observed data, independent variables (matrix like) 1875 | Parameter alpha: The total size of the tails (Float between 0 and 1) 1876 | Returns: Left and right interval bounds for each input (matrix like) 1877 | """ 1878 | y_posterior_samples = self.predict_posterior_samples(X) 1879 | return np.array([central_credible_interval(r, alpha=alpha) for r in y_posterior_samples]) 1880 |
1889 |
1900 |
1917 |
1918 |
1919 |
1890 |
1892 |
1893 |
1894 |
1895 |
1896 | def predict_highest_density_interval(
self, X, alpha=0.05)
1891 |The highest density interval prediction containing a (1-alpha) fraction of the posterior samples.
1897 |Parameter X: The observed data, independent variables (matrix like)
1898 |Parameter alpha: The total size of the tails (Float between 0 and 1)
1899 |Returns: Left and right interval bounds for each input (matrix like):
1901 |
1902 |
1915 |
1916 |
1903 |
1912 |
1913 |
1914 | def predict_highest_density_interval(self, X, alpha=0.05): 1904 | """The highest density interval prediction containing a (1-alpha) fraction of the posterior samples. 1905 | Parameter X: The observed data, independent variables (matrix like) 1906 | Parameter alpha: The total size of the tails (Float between 0 and 1) 1907 | Returns: Left and right interval bounds for each input (matrix like): 1908 | """ 1909 | y_posterior_samples = self.predict_posterior_samples(X) 1910 | return np.array([highest_density_interval(r, alpha=alpha) for r in y_posterior_samples]) 1911 |
1920 |
1930 |
1949 |
1950 |
1921 |
1923 |
1924 |
1925 |
1926 |
1927 | def predict_posterior_samples(
self, X)
1922 |Simulate posterior samples for a collection of observations.
1928 |Parameter X: The observed data, independent variables (matrix like)
1929 |Returns: The simulated posterior mean (matrix like)
1931 |
1932 |
1947 |
1948 |
1933 |
1944 |
1945 |
1946 | def predict_posterior_samples(self, X): 1934 | """Simulate posterior samples for a collection of observations. 1935 | Parameter X: The observed data, independent variables (matrix like) 1936 | Returns: The simulated posterior mean (matrix like) 1937 | """ 1938 | # Return a X_r x self.n_replications matrix 1939 | y_posterior_samples = np.zeros((len(X), self.n_replications)) 1940 | for i, m in enumerate(self.base_models_): 1941 | y_posterior_samples[:,i] = m.predict(X) 1942 | return y_posterior_samples 1943 |
Instance variables
1951 |
1952 |
1961 | var base_learner
1953 | 1954 | 1955 | 1956 | 1957 |
1958 |
1959 |
1960 |
1962 |
1971 | var memo
1963 | 1964 | 1965 | 1966 | 1967 |
1968 |
1969 |
1970 |
1972 |
1981 | var n_replications
1973 | 1974 | 1975 | 1976 | 1977 |
1978 |
1979 |
1980 |
1982 |
1991 | var resample_size
1983 | 1984 | 1985 | 1986 | 1987 |
1988 |
1989 |
1990 |