index int64 0 0 | repo_id stringlengths 26 205 | file_path stringlengths 51 246 | content stringlengths 8 433k | __index_level_0__ int64 0 10k |
|---|---|---|---|---|
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/util/ReinforcementLearningTest.java | package com.airbnb.aerosolve.core.util;
import com.airbnb.aerosolve.core.Example;
import com.airbnb.aerosolve.core.FeatureVector;
import com.airbnb.aerosolve.core.FunctionForm;
import com.airbnb.aerosolve.core.models.AbstractModel;
import com.airbnb.aerosolve.core.models.KernelModel;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class ReinforcementLearningTest {
private static final Logger log = LoggerFactory.getLogger(ReinforcementLearningTest.class);
StringDictionary makeDictionary() {
StringDictionary dict = new StringDictionary();
// The locations vary between 0 and 10
dict.possiblyAdd("S", "x", 0.0, 1.0);
dict.possiblyAdd("S", "y", 0.0, 1.0);
// The actions are +/- 1
dict.possiblyAdd("A", "dx", 0.0, 1.0);
dict.possiblyAdd("A", "dy", 0.0, 1.0);
return dict;
}
public HashMap makeState(double x, double y) {
HashMap stateFeatures = new HashMap<String, Double>();
stateFeatures.put("x", x);
stateFeatures.put("y", y);
return stateFeatures;
}
public HashMap makeAction(double dx, double dy) {
HashMap actionFeatures = new HashMap<String, Double>();
actionFeatures.put("dx", dx);
actionFeatures.put("dy", dy);
return actionFeatures;
}
public FeatureVector makeFeatureVector(HashMap state, HashMap action) {
HashMap floatFeatures = new HashMap<String, HashMap<String, Double>>();
floatFeatures.put("S", state);
floatFeatures.put("A", action);
FeatureVector featureVector = new FeatureVector();
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public ArrayList<FeatureVector> stateActions(double x, double y) {
HashMap currState = makeState(x, y);
ArrayList<FeatureVector> potential = new ArrayList<>();
HashMap up = makeAction(0.0f, 1.0f);
HashMap down = makeAction(0.0f, -1.0f);
HashMap left = makeAction(-1.0f, 0.0f);
HashMap right = makeAction(1.0f, 0.0f);
potential.add(makeFeatureVector(currState, up));
potential.add(makeFeatureVector(currState, down));
potential.add(makeFeatureVector(currState, left));
potential.add(makeFeatureVector(currState, right));
return potential;
}
AbstractModel makeModel() {
KernelModel model = new KernelModel();
StringDictionary dict = makeDictionary();
model.setDictionary(dict);
List<SupportVector> supportVectors = model.getSupportVectors();
Random rnd = new Random(12345);
for (double x = 0.0; x <= 10.0; x += 1.0) {
for (double y = 0.0; y <= 10.0; y += 1.0) {
ArrayList<FeatureVector> potential = stateActions(x, y);
for (FeatureVector sa : potential) {
FloatVector vec = dict.makeVectorFromSparseFloats(Util.flattenFeature(sa));
SupportVector sv = new SupportVector(vec, FunctionForm.RADIAL_BASIS_FUNCTION, 1.0f, 0.0f);
supportVectors.add(sv);
}
}
}
return model;
}
// In the cliffworld scenario, the agent starts at (0,0)
// There is a cliff in the region (2.0, 0.0) to (8.0, 2.0) if the agent steps in the cliff it gets a reward of -100 and teleports back to the start.
// Otherwise the reward is -1. If it hits the goal the reward is 10.0
//
//
//
//
// Start CLIFF Goal
// (0,0) CLIFF (10, 0)
public float runEpisode(AbstractModel model, int epoch, Random rnd, boolean epsGreedy) {
float sum = 0.0f;
double x = 0.0;
double y = 0.0;
FeatureVector prevStateAction = null;
float prevReward = 0.0f;
FeatureVector currStateAction = null;
float epsilon = 0.1f;
float learningRate = 0.1f;
float temperature = 10.0f;
if (epoch > 90) {
epsilon = 0.00f;
temperature = 0.1f;
learningRate = 0.001f;
}
boolean done = false;
while (!done) {
ArrayList<FeatureVector> potential = stateActions(x, y);
int pick = 0;
if (epsGreedy) {
pick = ReinforcementLearning.epsilonGreedyPolicy(model, potential, epsilon, rnd);
} else {
pick = ReinforcementLearning.softmaxPolicy(model, potential, temperature, rnd);
}
currStateAction = potential.get(pick);
switch (pick) {
case 0: y = y + 1; break;
case 1: y = y - 1; break;
case 2: x = x - 1; break;
case 3: x = x + 1;break;
}
float reward = -1.0f;
// Boundaries
if (x < 0.0) {
reward = -10.f;
x = 0.0;
}
if (x > 10.0) {
reward = -10.f;
x = 10.0;
}
if (y < 0.0) {
reward = -10.f;
y = 0.0;
}
if (y > 10.0) {
reward = -10.f;
y = 10.0;
}
// The cliff teleports back to the start.
if (x >= 2.0 && x <= 8.0 && y <= 2.0) {
x = y = 0.0;
reward = -100.0f;
}
// Goal
if (x >= 9.0f && y <= 1.0f) {
reward = 10.0f;
log.info("GOAL");
done = true;
}
if (prevStateAction != null) {
if (done) {
ReinforcementLearning.updateSARSA(model, currStateAction, reward, null, learningRate, 1.0f);
} else {
ReinforcementLearning.updateSARSA(model, prevStateAction, prevReward, currStateAction, learningRate, 1.0f);
}
}
prevStateAction = currStateAction;
sum += reward;
prevReward = reward;
}
return sum;
}
@Test
public void testSARSAGreedy() {
AbstractModel model = makeModel();
Random rnd = new Random(1234);
float sum = 0.0f;
for (int i = 0; i < 120; i++) {
sum = runEpisode(model, i, rnd, true);
log.info("Episode " + i + " score " + sum);
}
assertTrue(sum > -10.0f);
}
@Test
public void testSARSASoftmax() {
AbstractModel model = makeModel();
Random rnd = new Random(1234);
float sum = 0.0f;
for (int i = 0; i < 120; i++) {
sum = runEpisode(model, i, rnd, false);
log.info("Episode " + i + " score " + sum);
}
assertTrue(sum > -10.0f);
}
} | 7,100 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/images/HSVFeatureTest.java | package com.airbnb.aerosolve.core.images;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.awt.image.BufferedImage;
import java.util.List;
import static org.junit.Assert.assertTrue;
public class HSVFeatureTest {
private static final Logger log = LoggerFactory.getLogger(HSVFeatureTest.class);
public void testColorImage(int color, int token) {
BufferedImage image = new BufferedImage(10, 10, BufferedImage.TYPE_INT_RGB);
for (int x = 0; x < 10; x++) {
for (int y = 0; y < 10; y++) {
image.setRGB(x, y, color);
}
}
ImageFeature hsv = new HSVFeature();
hsv.analyze(image);
float[] feature = hsv.extractFeature(0, 0, 10, 10);
assertTrue(feature.length == hsv.featureSize());
for (int i = 0; i < hsv.featureSize(); i++) {
if (feature[i] > 0.0) {
log.info("Feature " + i + "=" + feature[i]);
}
if (i == token) {
assertTrue(feature[i] > 0.9);
assertTrue(feature[i] < 1.1);
} else {
assertTrue(feature[i] >= 0.0);
assertTrue(feature[i] <= 0.1);
}
}
}
@Test
public void testBlackImage() {
testColorImage(0, 0);
}
@Test
public void testRedImage() {
// Saturation should be 3 and hue should be 0.
testColorImage(0xff0000, 1 + 3 * 16 + 0);
}
@Test
public void testBlueImage() {
// Saturation should be 3 and hue should be 10.
// Blue is 240 hue degrees and so 260 / 360 * 16 ~ 10
testColorImage(0xff, 1 + 3 * 16 + 10);
}
@Test
public void testGreenImage() {
// Saturation should be 3 and hue should be 5.
// Green is 120 hue degrees and so 120 / 360 * 16 ~ 5
testColorImage(0x8200, 1 + 3 * 16 + 5);
}
@Test
public void testYellowImage() {
// Saturation should be 3 and hue should be 3.
// Yellow is 60 hue degrees and so 60 / 360 * 16 ~ 3
testColorImage(0x414100, 1 + 3 * 16 + 3);
}
@Test
public void testWhiteImage() {
// Saturation should be 0 and hue should be 0.
testColorImage(0xffffff, 1);
}
@Test
public void testRedGreenImage() {
BufferedImage image = new BufferedImage(10, 10, BufferedImage.TYPE_INT_RGB);
for (int x = 0; x < 10; x++) {
for (int y = 0; y < 10; y++) {
if (x % 2 == 0) {
image.setRGB(x, y, 0xff0000);
} else {
image.setRGB(x, y, 0x00ff00);
}
}
}
int token1 = 49;
int token2 = 54;
ImageFeature hsv = new HSVFeature();
hsv.analyze(image);
float[] feature = hsv.extractFeature(0, 0, 10, 10);
assertTrue(feature.length == hsv.featureSize());
for (int i = 0; i < hsv.featureSize(); i++) {
if (feature[i] > 0.0) {
log.info("Feature " + i + "=" + feature[i]);
}
if (i == token1 || i == token2) {
assertTrue(feature[i] > 0.49);
assertTrue(feature[i] < 0.51);
} else {
assertTrue(feature[i] >= 0.0);
assertTrue(feature[i] <= 0.1);
}
}
}
}
| 7,101 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/images/LBPFeatureTest.java | package com.airbnb.aerosolve.core.images;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.awt.image.BufferedImage;
import java.util.List;
import static org.junit.Assert.assertTrue;
public class LBPFeatureTest {
private static final Logger log = LoggerFactory.getLogger(LBPFeatureTest.class);
// There should be no gradients in a black image. All signals are zero.
@Test
public void testBlackImage() {
BufferedImage image = new BufferedImage(10, 10, BufferedImage.TYPE_BYTE_GRAY);
for (int x = 0; x < 10; x++) {
for (int y = 0; y < 10; y++) {
image.setRGB(x, y, 0);
}
}
ImageFeature lbp = new LBPFeature();
lbp.analyze(image);
float[] feature = lbp.extractFeature(0, 0, 10, 10);
assertTrue(feature.length == lbp.featureSize());
for (int i = 0; i < lbp.featureSize(); i++) {
if (i == 0) {
assertTrue(feature[i] >= 0.9);
assertTrue(feature[i] <= 1.1);
} else {
assertTrue(feature[i] >= 0.0);
assertTrue(feature[i] <= 0.1);
}
}
}
// Half the pixels have no left or right bar (so no bit set)
// the rest are all either on the left (bits 1, 8, 32 are set)
// or right (4, 16, 128)
@Test
public void testVerticalStripe() {
BufferedImage image = new BufferedImage(10, 10, BufferedImage.TYPE_INT_ARGB);
for (int x = 0; x < 10; x++) {
for (int y = 0; y < 10; y++) {
if (x % 3 == 0) {
image.setRGB(x, y, 0xffffff);
} else {
image.setRGB(x, y, 0);
}
}
}
ImageFeature lbp = new LBPFeature();
lbp.analyze(image);
float[] feature = lbp.extractFeature(0, 0, 10, 10);
assertTrue(feature.length == lbp.featureSize());
for (int i = 0; i < lbp.featureSize(); i++) {
if (feature[i] > 0.0) {
log.info("Feature " + i + "=" + feature[i]);
}
if (i == 0) {
assertTrue(feature[i] > 0.45);
assertTrue(feature[i] < 0.55);
} else if (i == 1 + 8 + 32 || i == 4 + 16 + 128){
assertTrue(feature[i] >= 0.2);
assertTrue(feature[i] <= 0.3);
}
}
}
// Half the pixels have no top or bottom bar (so no bit set)
// the rest are all either on the above (bits 1, 2, 4 are set)
// or below (32, 64, 128)
@Test
public void testHorizontalStripe() {
BufferedImage image = new BufferedImage(10, 10, BufferedImage.TYPE_INT_ARGB);
for (int x = 0; x < 10; x++) {
for (int y = 0; y < 10; y++) {
if (y % 3 == 0) {
image.setRGB(x, y, 0xaabbcc);
} else {
image.setRGB(x, y, 0);
}
}
}
ImageFeature lbp = new LBPFeature();
lbp.analyze(image);
float[] feature = lbp.extractFeature(0, 0, 10, 10);
assertTrue(feature.length == lbp.featureSize());
for (int i = 0; i < lbp.featureSize(); i++) {
if (feature[i] > 0.0) {
log.info("Feature " + i + "=" + feature[i]);
}
if (i == 0) {
assertTrue(feature[i] > 0.45);
assertTrue(feature[i] < 0.55);
} else if (i == 1 + 2 + 4 || i == 32 + 64 + 128){
assertTrue(feature[i] >= 0.2);
assertTrue(feature[i] <= 0.3);
}
}
}
}
| 7,102 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/images/RGBFeatureTest.java | package com.airbnb.aerosolve.core.images;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.awt.image.BufferedImage;
import java.util.List;
import static org.junit.Assert.assertTrue;
public class RGBFeatureTest {
private static final Logger log = LoggerFactory.getLogger(RGBFeatureTest.class);
@Test
public void testBlackImage() {
BufferedImage image = new BufferedImage(10, 10, BufferedImage.TYPE_BYTE_GRAY);
for (int x = 0; x < 10; x++) {
for (int y = 0; y < 10; y++) {
image.setRGB(x, y, 0);
}
}
ImageFeature rgb = new RGBFeature();
rgb.analyze(image);
float[] feature = rgb.extractFeature(0, 0, 10, 10);
assertTrue(feature.length == rgb.featureSize());
for (int i = 0; i < rgb.featureSize(); i++) {
if (feature[i] > 0.0) {
log.info("Feature " + i + "=" + feature[i]);
}
if (i == 0) {
assertTrue(feature[i] > 0.9);
assertTrue(feature[i] < 1.1);
} else {
assertTrue(feature[i] >= 0.0);
assertTrue(feature[i] <= 0.1);
}
}
}
@Test
public void testWhiteImage() {
BufferedImage image = new BufferedImage(10, 10, BufferedImage.TYPE_BYTE_GRAY);
for (int x = 0; x < 10; x++) {
for (int y = 0; y < 10; y++) {
image.setRGB(x, y, 0xffffff);
}
}
ImageFeature rgb = new RGBFeature();
rgb.analyze(image);
float[] feature = rgb.extractFeature(0, 0, 10, 10);
assertTrue(feature.length == rgb.featureSize());
for (int i = 0; i < rgb.featureSize(); i++) {
if (feature[i] > 0.0) {
log.info("Feature " + i + "=" + feature[i]);
}
if (i == rgb.featureSize() - 1) {
assertTrue(feature[i] > 0.9);
assertTrue(feature[i] < 1.1);
} else {
assertTrue(feature[i] >= 0.0);
assertTrue(feature[i] <= 0.1);
}
}
}
@Test
public void testColorImage() {
BufferedImage image = new BufferedImage(10, 10, BufferedImage.TYPE_INT_ARGB);
for (int x = 0; x < 10; x++) {
for (int y = 0; y < 10; y++) {
image.setRGB(x, y, 0xa3b2c1);
}
}
int token = (0xa >> 1 & 0x7) << 6 |
(0xb >> 1 & 0x7) << 3 |
(0xc >> 1 & 0x7) << 0;
ImageFeature rgb = new RGBFeature();
rgb.analyze(image);
float[] feature = rgb.extractFeature(0, 0, 10, 10);
assertTrue(feature.length == rgb.featureSize());
for (int i = 0; i < rgb.featureSize(); i++) {
if (feature[i] > 0.0) {
log.info("Feature " + i + "=" + feature[i]);
}
if (i == token) {
assertTrue(feature[i] > 0.9);
assertTrue(feature[i] < 1.1);
} else {
assertTrue(feature[i] >= 0.0);
assertTrue(feature[i] <= 0.1);
}
}
}
@Test
public void testColorImageSPMK() {
BufferedImage image = new BufferedImage(10, 10, BufferedImage.TYPE_INT_ARGB);
for (int x = 0; x < 10; x++) {
for (int y = 0; y < 10; y++) {
image.setRGB(x, y, 0xa3b2c1);
}
}
int token = (0xa >> 1 & 0x7) << 6 |
(0xb >> 1 & 0x7) << 3 |
(0xc >> 1 & 0x7) << 0;
ImageFeature rgb = new RGBFeature();
List<Float> feature = rgb.extractFeatureSPMK(image);
final int numBlocks = 1 + 2 * 2 + 4 * 4;
log.info("Feature size with SPMK = " + feature.size());
assertTrue(feature.size() == rgb.featureSize() * numBlocks);
for (int i = 0; i < rgb.featureSize() * numBlocks; i++) {
if (feature.get(i) > 0.0) {
log.info("Feature " + i + "=" + feature.get(i));
}
if (i % rgb.featureSize() == token) {
float weight = 0.25f;
// The first 1x1, 2x2 blocks should all be weight 0.25
// after that it should be weight 0.5
if (i > rgb.featureSize() * 5) {
weight = 0.5f;
}
assertTrue(feature.get(i) > weight - 0.01);
assertTrue(feature.get(i) < weight + 0.01);
} else {
assertTrue(feature.get(i) >= 0.0);
assertTrue(feature.get(i) <= 0.1);
}
}
}
@Test
public void testTwoColorImage() {
BufferedImage image = new BufferedImage(10, 10, BufferedImage.TYPE_INT_ARGB);
for (int x = 0; x < 10; x++) {
for (int y = 0; y < 10; y++) {
if (x % 2 == 0) {
image.setRGB(x, y, 0xa3b2c1);
} else {
image.setRGB(x, y, 0xd5e6f7);
}
}
}
int token1 = (0xa >> 1 & 0x7) << 6 |
(0xb >> 1 & 0x7) << 3 |
(0xc >> 1 & 0x7) << 0;
int token2 = (0xd >> 1 & 0x7) << 6 |
(0xe >> 1 & 0x7) << 3 |
(0xf >> 1 & 0x7) << 0;
ImageFeature rgb = new RGBFeature();
rgb.analyze(image);
float[] feature = rgb.extractFeature(0, 0, 10, 10);
assertTrue(feature.length == rgb.featureSize());
for (int i = 0; i < rgb.featureSize(); i++) {
if (feature[i] > 0.0) {
log.info("Feature " + i + "=" + feature[i]);
}
if (i == token1 || i == token2) {
assertTrue(feature[i] > 0.49);
assertTrue(feature[i] < 0.51);
} else {
assertTrue(feature[i] >= 0.0);
assertTrue(feature[i] <= 0.1);
}
}
}
}
| 7,103 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/images/HOGFeatureTest.java | package com.airbnb.aerosolve.core.images;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.awt.image.BufferedImage;
import java.util.List;
import static org.junit.Assert.assertTrue;
public class HOGFeatureTest {
private static final Logger log = LoggerFactory.getLogger(HOGFeatureTest.class);
// There should be no gradients in a black image. All signals are zero.
@Test
public void testBlackImage() {
BufferedImage image = new BufferedImage(10, 10, BufferedImage.TYPE_BYTE_GRAY);
for (int x = 0; x < 10; x++) {
for (int y = 0; y < 10; y++) {
image.setRGB(x, y, 0);
}
}
ImageFeature hog = new HOGFeature();
hog.analyze(image);
float[] feature = hog.extractFeature(0, 0, 10, 10);
assertTrue(feature.length == hog.featureSize());
for (int i = 0; i < hog.featureSize(); i++) {
assertTrue(feature[i] <= 0.1);
}
}
// Only the middle bin where theta is 0 should be active.
@Test
public void testVerticalStripe() {
BufferedImage image = new BufferedImage(10, 10, BufferedImage.TYPE_INT_ARGB);
for (int x = 0; x < 10; x++) {
for (int y = 0; y < 10; y++) {
if (x % 3 == 0) {
image.setRGB(x, y, 0xffffff);
} else {
image.setRGB(x, y, 0);
}
}
}
ImageFeature hog = new HOGFeature();
hog.analyze(image);
float[] feature = hog.extractFeature(0, 0, 10, 10);
assertTrue(feature.length == hog.featureSize());
for (int i = 0; i < hog.featureSize(); i++) {
if (feature[i] > 0.0) {
log.info("Feature " + i + "=" + feature[i]);
}
if (i == hog.featureSize() / 2) {
assertTrue(feature[i] > 0.9);
assertTrue(feature[i] < 1.1);
} else {
assertTrue(feature[i] >= 0.0);
assertTrue(feature[i] <= 0.1);
}
}
}
// Only the first and last bins where theta is -pi/2 or pi/2 should be active.
@Test
public void testHorizontalStripe() {
BufferedImage image = new BufferedImage(10, 10, BufferedImage.TYPE_INT_ARGB);
for (int x = 0; x < 10; x++) {
for (int y = 0; y < 10; y++) {
if (y % 3 == 0) {
image.setRGB(x, y, 0xaabbcc);
} else {
image.setRGB(x, y, 0);
}
}
}
ImageFeature hog = new HOGFeature();
hog.analyze(image);
float[] feature = hog.extractFeature(0, 0, 10, 10);
assertTrue(feature.length == hog.featureSize());
for (int i = 0; i < hog.featureSize(); i++) {
if (feature[i] > 0.0) {
log.info("Feature " + i + "=" + feature[i]);
}
// Horizontal lines can have angles -pi/2 or pi/2
if (i == 0 || i == hog.featureSize() - 1) {
assertTrue(feature[i] >= 0.49);
assertTrue(feature[i] <= 0.51);
} else {
assertTrue(feature[i] >= 0.0);
assertTrue(feature[i] <= 0.1);
}
}
}
// Draw a circle and see what the histogram of edges looks like.
// Since all angles are represented it should be more or less uniform.
@Test
public void testCircle() {
final int kSize = 32;
final int kRadiusSquared = 10 * 10;
BufferedImage image = new BufferedImage(kSize, kSize, BufferedImage.TYPE_INT_ARGB);
for (int x = 0; x < kSize; x++) {
for (int y = 0; y < kSize; y++) {
int dx = x - kSize / 2;
int dy = y - kSize / 2;
int r2 = dx * dx + dy * dy;
if (r2 <= kRadiusSquared) {
image.setRGB(x, y, r2);
} else {
image.setRGB(x, y, 0);
}
}
}
ImageFeature hog = new HOGFeature();
hog.analyze(image);
float[] feature = hog.extractFeature(0, 0, kSize, kSize);
assertTrue(feature.length == hog.featureSize());
for (int i = 0; i < hog.featureSize(); i++) {
if (feature[i] > 0.0) {
log.info("Feature " + i + "=" + feature[i]);
}
assertTrue(feature[i] >= 0.0);
assertTrue(feature[i] <= 0.2);
}
}
// The middle bins for each level of the pyramid should be active.
@Test
public void testVerticalStripeSPMK() {
BufferedImage image = new BufferedImage(32, 32, BufferedImage.TYPE_INT_ARGB);
for (int x = 0; x < 32; x++) {
for (int y = 0; y < 32; y++) {
if (x % 3 == 0) {
image.setRGB(x, y, 0xffffff);
} else {
image.setRGB(x, y, 0);
}
}
}
ImageFeature hog = new HOGFeature();
List<Float> feature = hog.extractFeatureSPMK(image);
final int numBlocks = 1 + 2 * 2 + 4 * 4;
log.info("Feature size with SPMK = " + feature.size());
assertTrue(feature.size() == hog.featureSize() * numBlocks);
for (int i = 0; i < hog.featureSize() * numBlocks; i++) {
if (feature.get(i) > 0.0) {
log.info("Feature " + i + "=" + feature.get(i));
}
if (i % hog.featureSize() == hog.featureSize() / 2) {
float weight = 0.25f;
// The first 1x1, 2x2 blocks should all be weight 0.25
// after that it should be weight 0.5
if (i > hog.featureSize() * 5) {
weight = 0.5f;
}
assertTrue(feature.get(i) > weight - 0.01);
assertTrue(feature.get(i) < weight + 0.01);
} else {
assertTrue(feature.get(i) >= 0.0);
assertTrue(feature.get(i) <= 0.1);
}
}
}
}
| 7,104 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/images/ImageFeatureExtractorTest.java | package com.airbnb.aerosolve.core.images;
import com.airbnb.aerosolve.core.FeatureVector;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.awt.image.BufferedImage;
import java.util.Map;
import java.util.List;
import static org.junit.Assert.assertTrue;
public class ImageFeatureExtractorTest {
private static final Logger log = LoggerFactory.getLogger(ImageFeatureExtractorTest.class);
public void validateFeature(Map<String, List<Double>> denseFeatures,
String name,
int expectedCount) {
assertTrue(denseFeatures.containsKey(name));
assertTrue(denseFeatures.get(name).size() == expectedCount);
log.info("feature " + name + "[0] = " + denseFeatures.get(name).get(0));
}
public void validateFeatureVector(FeatureVector featureVector) {
Map<String, List<Double>> denseFeatures = featureVector.getDenseFeatures();
assertTrue(denseFeatures != null);
assertTrue(denseFeatures.containsKey("rgb"));
final int kNumGrids = 1 + 4 + 16;
validateFeature(denseFeatures, "rgb", 512 * kNumGrids);
validateFeature(denseFeatures, "hog", 9 * kNumGrids);
validateFeature(denseFeatures, "lbp", 256 * kNumGrids);
validateFeature(denseFeatures, "hsv", 65 * kNumGrids);
}
@Test
public void testBlackImage() {
BufferedImage image = new BufferedImage(10, 10, BufferedImage.TYPE_BYTE_GRAY);
ImageFeatureExtractor featureExtractor = ImageFeatureExtractor.getInstance();
FeatureVector featureVector = featureExtractor.getFeatureVector(image);
validateFeatureVector(featureVector);
}
}
| 7,105 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/features/FeaturesTest.java | package com.airbnb.aerosolve.core.features;
import com.airbnb.aerosolve.core.Example;
import com.airbnb.aerosolve.core.FeatureVector;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
import org.junit.Test;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import static org.junit.Assert.*;
public class FeaturesTest {
public static Features createFeature() {
Object[] values = new Object[7];
String[] names = new String[7];
names[0] = Features.LABEL;
values[0] = new Double(5.0);
names[1] = "f_RAW";
values[1] = "raw_feature";
names[2] = "K_star";
values[2] = "monkey";
names[3] = "K_good";
values[3] = Boolean.FALSE;
names[4] = "S_speed";
values[4] = new Double(10.0);
names[5] = "X_jump";
values[5] = null;
names[6] = "_meta_id_listing";
values[6] = 12345;
return Features.builder().names(names).values(values).build();
}
public static Features createMultiClassFeature() {
Object[] values = new Object[1];
String[] names = new String[1];
names[0] = Features.LABEL;
values[0] = "a:1,b:2";
return Features.builder().names(names).values(values).build();
}
@Test
public void toExample() throws Exception {
Example example = createFeature().toExample(false);
FeatureVector featureVector = example.getExample().get(0);
final Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
final Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
final Map<String, String> metadata = example.getMetadata();
// we have default BIAS
assertEquals(4, stringFeatures.size());
Set<String> stringFeature = stringFeatures.get("f");
assertEquals(1, stringFeature.size());
assertTrue(stringFeature.contains("raw_feature"));
stringFeature = stringFeatures.get("K");
assertEquals(2, stringFeature.size());
assertTrue(stringFeature.contains("star:monkey"));
assertTrue(stringFeature.contains("good:F"));
stringFeature = stringFeatures.get("X");
assertNull(stringFeature);
stringFeature = stringFeatures.get(Features.MISS);
assertEquals(1, stringFeature.size());
assertTrue(stringFeature.contains("X_jump"));
assertEquals(2, floatFeatures.size());
Map<String, Double> floatFeature = floatFeatures.get("S");
assertEquals(1, floatFeature.size());
assertEquals(10.0, floatFeature.get("speed"), 0);
floatFeature = floatFeatures.get(Features.LABEL);
assertEquals(1, floatFeature.size());
assertEquals(5.0, floatFeature.get(Features.LABEL_FEATURE_NAME), 0);
assertEquals(1, metadata.size());
assertEquals("12345", metadata.get("id_listing"));
}
@Test
public void toExampleMultiClass() throws Exception {
Example example = createMultiClassFeature().toExample(true);
FeatureVector featureVector = example.getExample().get(0);
final Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
assertEquals(1, floatFeatures.size());
Map<String, Double> floatFeature = floatFeatures.get(Features.LABEL);
assertEquals(2, floatFeature.size());
assertEquals(1, floatFeature.get("a"), 0);
assertEquals(2, floatFeature.get("b"), 0);
}
@Test
public void addNumberFeature() throws Exception {
Pair<String, String> featurePair = new ImmutablePair<>("family", "feature");
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Features.addNumberFeature(4, featurePair, floatFeatures);
Map<String, Double> feature = floatFeatures.get("family");
assertEquals(1, feature.size());
assertEquals(4, feature.get("feature"), 0);
featurePair = new ImmutablePair<>("family", "feature_float");
Features.addNumberFeature(5.0f, featurePair, floatFeatures);
assertEquals(2, feature.size());
assertEquals(5.0, feature.get("feature_float"), 0);
}
@Test
public void addBoolFeature() throws Exception {
Pair<String, String> featurePair = new ImmutablePair<>("family", "feature");
Map<String, Set<String>> stringFeatures = new HashMap<>();
Features.addBoolFeature(false, featurePair, stringFeatures);
Features.addBoolFeature(true, featurePair, stringFeatures);
Set<String> feature = stringFeatures.get("family");
assertEquals(2, feature.size());
assertTrue(feature.contains("feature:T"));
assertTrue(feature.contains("feature:F"));
}
@Test
public void addStringFeature() throws Exception {
Pair<String, String> featurePair = new ImmutablePair<>("family", "feature");
Map<String, Set<String>> stringFeatures = new HashMap<>();
Features.addStringFeature("value", featurePair, stringFeatures);
Pair<String, String> raw = new ImmutablePair<>("family", Features.RAW);
Features.addStringFeature("feature_1", raw, stringFeatures);
Set<String> feature = stringFeatures.get("family");
assertEquals(2, feature.size());
assertTrue(feature.contains("feature:value"));
assertTrue(feature.contains("feature_1"));
}
@Test
public void addMultiClassLabel() throws Exception {
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Features.addMultiClassLabel("a:1,b:2", floatFeatures);
Map<String, Double> feature = floatFeatures.get(Features.LABEL);
assertEquals(2, feature.size());
assertEquals(1, feature.get("a"), 0);
assertEquals(2, feature.get("b"), 0);
}
@Test (expected = RuntimeException.class)
public void addMultiClassManyColon() throws Exception {
Features.addMultiClassLabel("a:1:2,b:2", Collections.EMPTY_MAP);
}
@Test (expected = RuntimeException.class)
public void addMultiClassLabelNoolon() throws Exception {
Features.addMultiClassLabel("abc,b:2", Collections.EMPTY_MAP);
}
@Test
public void isLabel() throws Exception {
assertTrue(Features.isLabel(Features.getFamily("LABEL")));
assertFalse(Features.isLabel(Features.getFamily("LABE_ab")));
}
@Test(expected = RuntimeException.class)
public void getFamilyEmpty() throws Exception {
Pair<String, String> p = Features.getFamily("");
}
@Test
public void getDefaultStringFamily() throws Exception {
Pair<String, String> p = Features.getFamily("string");
assertEquals("", p.getLeft());
assertEquals(Features.DEFAULT_STRING_FAMILY, Features.getStringFamily(p));
}
@Test
public void getDefaultFloatFamily() throws Exception {
Pair<String, String> p = Features.getFamily("float");
assertEquals("", p.getLeft());
assertEquals(Features.DEFAULT_FLOAT_FAMILY, Features.getFloatFamily(p));
}
@Test(expected = RuntimeException.class)
public void getFamilyPrefix() throws Exception {
Pair<String, String> p = Features.getFamily("_abc");
}
@Test
public void getFamily() throws Exception {
Pair<String, String> p = Features.getFamily("f_ab_cd");
assertEquals(p.getLeft(), "f");
assertEquals(p.getRight(), "ab_cd");
}
}
| 7,106 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/features/FeatureGenTest.java | package com.airbnb.aerosolve.core.features;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
public class FeatureGenTest {
@Test
public void add() throws Exception {
FeatureMapping m = new FeatureMapping(100);
String[] doubleNames = {"a", "b"};
m.add(Double.class, doubleNames);
String[] booleanNames = {"c", "d"};
m.add(Boolean.class, booleanNames);
String[] strNames = {"e", "f"};
m.add(String.class, strNames);
m.finish();
FeatureGen f = new FeatureGen(m);
f.add(new float[]{Float.MIN_VALUE, 5}, Double.class);
Features p = f.gen();
assertEquals(p.names.length, 6);
assertEquals(p.values[0], null);
assertEquals((Double) p.values[1], 5, 0.1);
}
} | 7,107 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/features/FeatureMappingTest.java | package com.airbnb.aerosolve.core.features;
import org.junit.Test;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
public class FeatureMappingTest {
@Test
public void add() throws Exception {
FeatureMapping m = new FeatureMapping(100);
String[] doubleNames = {"a", "b"};
m.add(Double.class, doubleNames);
String[] booleanNames = {"c", "d"};
m.add(Boolean.class, booleanNames);
String[] strNames = {"e", "f"};
m.add(String.class, strNames);
m.finish();
assertEquals(m.getNames().length, 6);
assertArrayEquals(m.getNames(),
new String[]{"a", "b", "c", "d", "e", "f"});
assertEquals(m.getMapping().get(String.class).start, 4);
assertEquals(m.getMapping().get(String.class).length, 2);
}
} | 7,108 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/models/KDTreeModelTest.java | package com.airbnb.aerosolve.core.models;
import com.airbnb.aerosolve.core.KDTreeNode;
import com.airbnb.aerosolve.core.KDTreeNodeType;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
public class KDTreeModelTest {
private static final Logger log = LoggerFactory.getLogger(KDTreeModelTest.class);
// 4
// |--------------- y = 2
// 1 | 2 3
// x = 1
public static KDTreeNode[] getTestNodes() {
KDTreeNode parent = new KDTreeNode();
parent.setNodeType(KDTreeNodeType.X_SPLIT);
parent.setSplitValue(1.0);
parent.setLeftChild(1);
parent.setRightChild(2);
KDTreeNode one = new KDTreeNode();
one.setNodeType(KDTreeNodeType.LEAF);
KDTreeNode two = new KDTreeNode();
two.setNodeType(KDTreeNodeType.Y_SPLIT);
two.setSplitValue(2.0);
two.setLeftChild(3);
two.setRightChild(4);
KDTreeNode three = new KDTreeNode();
three.setNodeType(KDTreeNodeType.LEAF);
KDTreeNode four = new KDTreeNode();
four.setNodeType(KDTreeNodeType.LEAF);
KDTreeNode[] arr = {parent, one, two, three, four};
return arr;
}
@Test
public void testLeaf() {
KDTreeModel tree = new KDTreeModel(getTestNodes());
int leaf = tree.leaf(-1.0, -1.0);
assertEquals(1, leaf);
leaf = tree.leaf(1.1, 0.0);
assertEquals(3, leaf);
leaf = tree.leaf(1.0, 2.0);
assertEquals(4, leaf);
leaf = tree.leaf(0.99, 2.1);
assertEquals(1, leaf);
}
@Test
public void testQuery() {
KDTreeModel tree = new KDTreeModel(getTestNodes());
ArrayList<Integer> res1 = tree.query(-1.0, -1.0);
assertEquals(2, res1.size());
assertEquals(0, res1.get(0).intValue());
assertEquals(1, res1.get(1).intValue());
ArrayList<Integer> res2 = tree.query(1.1, 0.0);
assertEquals(3, res2.size());
assertEquals(0, res2.get(0).intValue());
assertEquals(2, res2.get(1).intValue());
assertEquals(3, res2.get(2).intValue());
ArrayList<Integer> res3 = tree.query(1.0, 2.0);
assertEquals(3, res3.size());
assertEquals(0, res3.get(0).intValue());
assertEquals(2, res3.get(1).intValue());
assertEquals(4, res3.get(2).intValue());
ArrayList<Integer> res4 = tree.query(0.99, 2.1);
assertEquals(2, res4.size());
assertEquals(0, res4.get(0).intValue());
assertEquals(1, res4.get(1).intValue());
}
private Set<Integer> toSet(ArrayList<Integer> arr) {
Set<Integer> set = new HashSet<>();
for (Integer i : arr) {
set.add(i);
}
return set;
}
@Test
public void testQueryBox() {
KDTreeModel tree = new KDTreeModel(getTestNodes());
// This box covers all nodes
Set<Integer> q1 = toSet(tree.queryBox(-10.0, -10.0, 10.0, 10.0));
assertEquals(q1.size(), 5);
assertTrue(q1.contains(0));
assertTrue(q1.contains(1));
assertTrue(q1.contains(2));
assertTrue(q1.contains(3));
assertTrue(q1.contains(4));
// This box covers only nodes 0 and 1
Set<Integer> q2 = toSet(tree.queryBox(-10.0, -10.0, 0.9, 10.0));
assertEquals(q2.size(), 2);
assertTrue(q2.contains(0));
assertTrue(q2.contains(1));
// This box covers only nodes 0, 1, 2, 4
Set<Integer> q3 = toSet(tree.queryBox(-10.0, 2.0, 2.0, 10.0));
assertEquals(q3.size(), 4);
assertTrue(q3.contains(0));
assertTrue(q3.contains(1));
assertTrue(q3.contains(2));
assertTrue(q3.contains(4));
// This box covers only node 0, 2, 3
Set<Integer> q4 = toSet(tree.queryBox(1.1, 0.0, 10.0, 1.9));
assertEquals(q4.size(), 3);
assertTrue(q4.contains(0));
assertTrue(q4.contains(2));
assertTrue(q4.contains(3));
// This box covers all nodes except 1
Set<Integer> q5 = toSet(tree.queryBox(1.0, 0.0, 10.0, 2.0));
assertEquals(q5.size(), 4);
assertTrue(q5.contains(0));
assertTrue(q5.contains(2));
assertTrue(q5.contains(3));
assertTrue(q5.contains(4));
}
} | 7,109 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/models/MlpModelTest.java | package com.airbnb.aerosolve.core.models;
import com.airbnb.aerosolve.core.FeatureVector;
import com.airbnb.aerosolve.core.FunctionForm;
import com.airbnb.aerosolve.core.ModelHeader;
import com.airbnb.aerosolve.core.ModelRecord;
import com.airbnb.aerosolve.core.util.FloatVector;
import com.airbnb.aerosolve.core.util.Util;
import com.google.common.base.Optional;
import org.junit.Test;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.CharArrayWriter;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.assertEquals;
/*
Test the MLP model
*/
public class MlpModelTest {
public FeatureVector makeFeatureVector() {
FeatureVector featureVector = new FeatureVector();
HashMap stringFeatures = new HashMap<String, HashSet<String>>();
featureVector.setStringFeatures(stringFeatures);
HashMap floatFeatures = new HashMap<String, HashMap<String, Double>>();
featureVector.setFloatFeatures(floatFeatures);
HashMap feature = new HashMap<String, Float>();
feature.put("a", 1.0);
feature.put("b", 2.0);
floatFeatures.put("in", feature);
return featureVector;
}
public MlpModel makeMlpModel(FunctionForm func) {
// construct a network with 1 hidden layer
// and there are 3 nodes in the hidden layer
ArrayList nodeNum = new ArrayList(2);
nodeNum.add(3);
nodeNum.add(1);
// assume bias at each node are zeros
ArrayList activations = new ArrayList();
activations.add(func);
activations.add(func);
MlpModel model = new MlpModel(activations, nodeNum);
// set input layer
HashMap inputLayer = new HashMap<>();
HashMap inner = new HashMap<>();
FloatVector f11 = new FloatVector(3);
f11.set(0, 0.0f);
f11.set(1, 1.0f);
f11.set(2, 1.0f);
FloatVector f12 = new FloatVector(3);
f12.set(0, 1.0f);
f12.set(1, 1.0f);
f12.set(2, 0.0f);
inner.put("a", f11);
inner.put("b", f12);
inputLayer.put("in", inner);
model.setInputLayerWeights(inputLayer);
// set hidden layer
HashMap hiddenLayer = new HashMap<>();
FloatVector f21 = new FloatVector(1);
FloatVector f22 = new FloatVector(1);
FloatVector f23 = new FloatVector(1);
f21.set(0, 0.5f);
f22.set(0, 1.0f);
f23.set(0, 2.0f);
ArrayList hidden = new ArrayList(3);
hidden.add(f21);
hidden.add(f22);
hidden.add(f23);
hiddenLayer.put(0, hidden);
model.setHiddenLayerWeights(hiddenLayer);
return model;
}
@Test
public void testConstructedModel() {
MlpModel model = makeMlpModel(FunctionForm.RELU);
assertEquals(model.getNumHiddenLayers(), 1);
assertEquals(model.getActivationFunction().get(0), FunctionForm.RELU);
assertEquals(model.getHiddenLayerWeights().size(), 1);
assertEquals(model.getHiddenLayerWeights().get(0).size(), 3);
assertEquals(model.getInputLayerWeights().entrySet().size(), 1);
assertEquals(model.getInputLayerWeights().get("in").entrySet().size(), 2);
assertEquals(model.getInputLayerWeights().get("in").get("a").length(), 3);
assertEquals(model.getInputLayerWeights().get("in").get("b").length(), 3);
}
@Test
public void testScoring() {
FeatureVector fv = makeFeatureVector();
MlpModel model = makeMlpModel(FunctionForm.RELU);
float output = model.scoreItem(fv);
assertEquals(output, 6.0f, 1e-10f);
}
@Test
public void testSave() {
StringWriter strWriter = new StringWriter();
BufferedWriter writer = new BufferedWriter(strWriter);
MlpModel model = makeMlpModel(FunctionForm.RELU);
try {
model.save(writer);
writer.close();
} catch (IOException e) {
assertTrue("Could not save", false);
}
}
@Test
public void testLoad() {
CharArrayWriter charWriter = new CharArrayWriter();
BufferedWriter writer = new BufferedWriter(charWriter);
// create header record
ModelHeader header = new ModelHeader();
header.setModelType("multilayer_perceptron");
header.setNumHiddenLayers(1);
ArrayList<Integer> nodeNum = new ArrayList<>(2);
nodeNum.add(3);
nodeNum.add(1);
header.setNumberHiddenNodes(nodeNum);
header.setNumRecords(2);
ModelRecord record1 = new ModelRecord();
record1.setModelHeader(header);
// create records for input layer
ModelRecord record2 = new ModelRecord();
record2.setFeatureFamily("in");
record2.setFeatureName("a");
ArrayList<Double> in1 = new ArrayList<>();
in1.add(0.0);
in1.add(1.0);
in1.add(1.0);
record2.setWeightVector(in1);
ModelRecord record3 = new ModelRecord();
record3.setFeatureFamily("in");
record3.setFeatureName("b");
ArrayList<Double> in2 = new ArrayList<>();
in2.add(1.0);
in2.add(1.0);
in2.add(0.0);
record3.setWeightVector(in2);
// create records for bias
ModelRecord record4 = new ModelRecord();
ArrayList<Double> b1 = new ArrayList<>();
b1.add(0.0);
b1.add(0.0);
b1.add(0.0);
record4.setWeightVector(b1);
record4.setFunctionForm(FunctionForm.RELU);
ModelRecord record5 = new ModelRecord();
ArrayList<Double> b2 = new ArrayList<>();
b2.add(0.0);
record5.setWeightVector(b2);
record5.setFunctionForm(FunctionForm.RELU);
// create records for hidden layer
ModelRecord record6 = new ModelRecord();
ArrayList<Double> h1 = new ArrayList<>();
h1.add(0.5);
record6.setWeightVector(h1);
ModelRecord record7 = new ModelRecord();
ArrayList<Double> h2 = new ArrayList<>();
h2.add(1.0);
record7.setWeightVector(h2);
ModelRecord record8 = new ModelRecord();
ArrayList<Double> h3 = new ArrayList<>();
h3.add(2.0);
record8.setWeightVector(h3);
try {
writer.write(Util.encode(record1) + "\n");
writer.write(Util.encode(record2) + "\n");
writer.write(Util.encode(record3) + "\n");
writer.write(Util.encode(record4) + "\n");
writer.write(Util.encode(record5) + "\n");
writer.write(Util.encode(record6) + "\n");
writer.write(Util.encode(record7) + "\n");
writer.write(Util.encode(record8) + "\n");
writer.close();
} catch (IOException e) {
assertTrue("Could not write", false);
}
String serialized = charWriter.toString();
assertTrue(serialized.length() > 0);
StringReader strReader = new StringReader(serialized);
BufferedReader reader = new BufferedReader(strReader);
FeatureVector fv = makeFeatureVector();
try {
Optional<AbstractModel> model = ModelFactory.createFromReader(reader);
assertTrue(model.isPresent());
float s = model.get().scoreItem(fv);
assertEquals(s, 6.0f, 1e-10f);
} catch (IOException e) {
assertTrue("Could not read", false);
}
}
}
| 7,110 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/models/LowRankLinearModelTest.java | package com.airbnb.aerosolve.core.models;
import com.airbnb.aerosolve.core.FeatureVector;
import com.airbnb.aerosolve.core.LabelDictionaryEntry;
import com.airbnb.aerosolve.core.ModelHeader;
import com.airbnb.aerosolve.core.ModelRecord;
import com.airbnb.aerosolve.core.MulticlassScoringResult;
import com.airbnb.aerosolve.core.util.FloatVector;
import com.airbnb.aerosolve.core.util.Util;
import com.google.common.base.Optional;
import org.junit.Test;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.CharArrayWriter;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.assertEquals;
/*
Test the low rank linear model
*/
public class LowRankLinearModelTest {
ArrayList<LabelDictionaryEntry> makeLabelDictionary() {
ArrayList<LabelDictionaryEntry> labelDictionary = new ArrayList<>();
// construct label dictionary
LabelDictionaryEntry animalLabel = new LabelDictionaryEntry();
animalLabel.setLabel("A");
animalLabel.setCount(1);
labelDictionary.add(animalLabel);
LabelDictionaryEntry colorLabel = new LabelDictionaryEntry();
colorLabel.setLabel("C");
colorLabel.setCount(1);
labelDictionary.add(colorLabel);
LabelDictionaryEntry fruitLabel = new LabelDictionaryEntry();
fruitLabel.setLabel("F");
fruitLabel.setCount(1);
labelDictionary.add(fruitLabel);
return labelDictionary;
}
Map<String, FloatVector> makeLabelWeightVector() {
Map<String, FloatVector> labelWeights = new HashMap<>();
float[] animalFeature = {1.0f, 0.0f, 0.0f};
float[] colorFeature = {0.0f, 1.0f, 0.0f};
float[] fruitFeature = {0.0f, 0.0f, 1.0f};
labelWeights.put("A", new FloatVector(animalFeature));
labelWeights.put("C", new FloatVector(colorFeature));
labelWeights.put("F", new FloatVector(fruitFeature));
return labelWeights;
}
LowRankLinearModel makeLowRankLinearModel() {
// A naive model with three classes 'animal', 'color' and 'fruit'
// and the size of embedding D = number of labels, W is an identity matrix
LowRankLinearModel model = new LowRankLinearModel();
model.setEmbeddingDimension(3);
model.setLabelDictionary(makeLabelDictionary());
// construct featureWeightVector
Map<String, Map<String, FloatVector>> featureWeights = new HashMap<>();
Map<String, FloatVector> animalFeatures = new HashMap<>();
Map<String, FloatVector> colorFeatures = new HashMap<>();
Map<String, FloatVector> fruitFeatures = new HashMap<>();
String[] animalWords = {"cat", "dog", "horse", "fish"};
String[] colorWords = {"red", "black", "blue", "white", "yellow"};
String[] fruitWords = {"apple", "kiwi", "pear", "peach"};
float[] animalFeature = {1.0f, 0.0f, 0.0f};
float[] colorFeature = {0.0f, 1.0f, 0.0f};
float[] fruitFeature = {0.0f, 0.0f, 1.0f};
for (String word: animalWords) {
animalFeatures.put(word, new FloatVector(animalFeature));
}
for (String word: colorWords) {
colorFeatures.put(word, new FloatVector(colorFeature));
}
for (String word: fruitWords) {
fruitFeatures.put(word, new FloatVector(fruitFeature));
}
featureWeights.put("a", animalFeatures);
featureWeights.put("c", colorFeatures);
featureWeights.put("f", fruitFeatures);
model.setFeatureWeightVector(featureWeights);
// set labelWeightVector
model.setLabelWeightVector(makeLabelWeightVector());
model.buildLabelToIndex();
return model;
}
public FeatureVector makeFeatureVector(String label) {
FeatureVector featureVector = new FeatureVector();
HashMap stringFeatures = new HashMap<String, HashSet<String>>();
featureVector.setStringFeatures(stringFeatures);
HashMap floatFeatures = new HashMap<String, HashMap<String, Double>>();
featureVector.setFloatFeatures(floatFeatures);
HashMap feature = new HashMap<String, Float>();
switch (label) {
case "animal": {
feature.put("cat", 1.0);
feature.put("dog", 2.0);
floatFeatures.put("a", feature);
break;
}
case "color": {
feature.put("red", 2.0);
feature.put("black", 4.0);
floatFeatures.put("c", feature);
break;
}
case "fruit": {
feature.put("apple", 1.0);
feature.put("kiwi", 3.0);
floatFeatures.put("f", feature);
break;
}
default: break;
}
return featureVector;
}
@Test
public void testScoreEmptyFeature() {
FeatureVector featureVector = new FeatureVector();
LowRankLinearModel model = makeLowRankLinearModel();
ArrayList<MulticlassScoringResult> score = model.scoreItemMulticlass(featureVector);
assertEquals(score.size(), 3);
assertEquals(0.0f, score.get(0).score, 1e-10f);
assertEquals(0.0f, score.get(1).score, 1e-10f);
assertEquals(0.0f, score.get(2).score, 1e-10f);
}
@Test
public void testScoreNonEmptyFeature() {
FeatureVector animalFv = makeFeatureVector("animal");
FeatureVector colorFv = makeFeatureVector("color");
FeatureVector fruitFv = makeFeatureVector("fruit");
LowRankLinearModel model = makeLowRankLinearModel();
ArrayList<MulticlassScoringResult> s1 = model.scoreItemMulticlass(animalFv);
assertEquals(s1.size(), 3);
assertEquals(0.0f, s1.get(0).score, 3.0f);
assertEquals(0.0f, s1.get(1).score, 1e-10f);
assertEquals(0.0f, s1.get(2).score, 1e-10f);
ArrayList<MulticlassScoringResult> s2 = model.scoreItemMulticlass(colorFv);
assertEquals(s2.size(), 3);
assertEquals(0.0f, s2.get(0).score, 1e-10f);
assertEquals(0.0f, s2.get(1).score, 6.0f);
assertEquals(0.0f, s2.get(2).score, 1e-10f);
ArrayList<MulticlassScoringResult> s3 = model.scoreItemMulticlass(fruitFv);
assertEquals(s3.size(), 3);
assertEquals(0.0f, s3.get(0).score, 1e-10f);
assertEquals(0.0f, s3.get(1).score, 1e-10f);
assertEquals(0.0f, s3.get(2).score, 4.0f);
}
@Test
public void testLoad() {
CharArrayWriter charWriter = new CharArrayWriter();
BufferedWriter writer = new BufferedWriter(charWriter);
ModelHeader header = new ModelHeader();
header.setModelType("low_rank_linear");
header.setLabelDictionary(makeLabelDictionary());
Map<String, FloatVector> labelWeightVector = makeLabelWeightVector();
Map<String, java.util.List<Double>> labelEmbedding = new HashMap<>();
for (Map.Entry<String, FloatVector> labelRepresentation : labelWeightVector.entrySet()) {
float[] values = labelRepresentation.getValue().getValues();
ArrayList<Double> arrayList = new ArrayList<>();
for (int i = 0; i < 3; i++) {
arrayList.add((double) values[i]);
}
labelEmbedding.put(labelRepresentation.getKey(), arrayList);
}
header.setLabelEmbedding(labelEmbedding);
header.setNumRecords(4);
ArrayList<Double> ws = new ArrayList<>();
ws.add(1.0);
ws.add(0.0);
ws.add(0.0);
ModelRecord record1 = new ModelRecord();
record1.setModelHeader(header);
ModelRecord record2 = new ModelRecord();
record2.setFeatureFamily("a");
record2.setFeatureName("cat");
record2.setWeightVector(ws);
ModelRecord record3 = new ModelRecord();
record3.setFeatureFamily("a");
record3.setFeatureName("dog");
record3.setWeightVector(ws);
ModelRecord record4 = new ModelRecord();
record4.setFeatureFamily("a");
record4.setFeatureName("fish");
record4.setWeightVector(ws);
ModelRecord record5 = new ModelRecord();
record5.setFeatureFamily("a");
record5.setFeatureName("horse");
record5.setWeightVector(ws);
try {
writer.write(Util.encode(record1) + "\n");
writer.write(Util.encode(record2) + "\n");
writer.write(Util.encode(record3) + "\n");
writer.write(Util.encode(record4) + "\n");
writer.write(Util.encode(record5) + "\n");
writer.close();
} catch (IOException e) {
assertTrue("Could not write", false);
}
String serialized = charWriter.toString();
assertTrue(serialized.length() > 0);
StringReader strReader = new StringReader(serialized);
BufferedReader reader = new BufferedReader(strReader);
FeatureVector animalFv = makeFeatureVector("animal");
FeatureVector colorFv = makeFeatureVector("color");
try {
Optional<AbstractModel> model = ModelFactory.createFromReader(reader);
assertTrue(model.isPresent());
ArrayList<MulticlassScoringResult> s1 = model.get().scoreItemMulticlass(animalFv);
assertEquals(s1.size(), 3);
assertEquals(0.0f, s1.get(0).score, 3.0f);
assertEquals(0.0f, s1.get(1).score, 1e-10f);
assertEquals(0.0f, s1.get(2).score, 1e-10f);
ArrayList<MulticlassScoringResult> s2 = model.get().scoreItemMulticlass(colorFv);
assertEquals(s2.size(), 3);
assertEquals(0.0f, s2.get(0).score, 1e-10f);
assertEquals(0.0f, s2.get(1).score, 1e-10f);
assertEquals(0.0f, s2.get(2).score, 1e-10f);
} catch (IOException e) {
assertTrue("Could not read", false);
}
}
@Test
public void testSave() {
StringWriter strWriter = new StringWriter();
BufferedWriter writer = new BufferedWriter(strWriter);
LowRankLinearModel model = makeLowRankLinearModel();
try {
model.save(writer);
writer.close();
} catch (IOException e) {
assertTrue("Could not save", false);
}
}
}
| 7,111 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/models/NDTreeModelTest.java | package com.airbnb.aerosolve.core.models;
import com.airbnb.aerosolve.core.NDTreeNode;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static com.airbnb.aerosolve.core.models.NDTreeModel.LEAF;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
public class NDTreeModelTest {
private static final Logger log = LoggerFactory.getLogger(NDTreeModelTest.class);
private static NDTreeNode[] getNDTreeNodes2DWithMinMax() {
NDTreeNode parent = new NDTreeNode();
parent.setAxisIndex(0);
parent.setSplitValue(2.0);
parent.setLeftChild(1);
parent.setRightChild(2);
parent.setMin(Arrays.asList(0.0, 0.0));
parent.setMax(Arrays.asList(6.0, 6.0));
NDTreeNode one = new NDTreeNode();
one.setAxisIndex(LEAF);
one.setMin(Arrays.asList(0.0,0.0));
one.setMax(Arrays.asList(1.0,6.0));
NDTreeNode two = new NDTreeNode();
two.setAxisIndex(1);
two.setSplitValue(2.0);
two.setLeftChild(3);
two.setRightChild(4);
two.setMin(Arrays.asList(2.5, 0.0));
two.setMax(Arrays.asList(6.0, 6.0));
NDTreeNode three = new NDTreeNode();
three.setAxisIndex(LEAF);
three.setMin(Arrays.asList(2.5,1.0));
three.setMax(Arrays.asList(6.0,1.0));
NDTreeNode four = new NDTreeNode();
four.setAxisIndex(0);
four.setSplitValue(4.0);
four.setLeftChild(5);
four.setRightChild(6);
four.setMin(Arrays.asList(2.5,3.0));
four.setMax(Arrays.asList(6.0,6.0));
NDTreeNode five = new NDTreeNode();
five.setAxisIndex(LEAF);
five.setMin(Arrays.asList(3.0,3.0));
five.setMax(Arrays.asList(3.5,3.5));
NDTreeNode six = new NDTreeNode();
six.setAxisIndex(LEAF);
six.setMin(Arrays.asList(4.5,4.0));
six.setMax(Arrays.asList(6.0,6.0));
return new NDTreeNode[]{parent, one, two, three, four, five, six};
}
@Test
public void updateWithSplitValue() {
NDTreeNode[] nodes = getNDTreeNodes2DWithMinMax();
NDTreeModel.updateWithSplitValue(nodes);
NDTreeNode[] oldNodes = getNDTreeNodes2DWithMinMax();
assertEquals(oldNodes[0].max, nodes[0].max);
assertEquals(nodes[0].splitValue, nodes[1].getMax().get(0), 0);
assertEquals(nodes[0].splitValue, nodes[2].getMin().get(0), 0);
assertEquals(2.5, nodes[3].getMin().get(0), 0);
assertEquals(1, nodes[3].getMax().get(1), 0);
assertEquals(1, nodes[3].getMin().get(1), 0);
assertEquals(nodes[2].splitValue, nodes[4].getMin().get(1), 0);
assertEquals(nodes[4].splitValue, nodes[5].getMax().get(0), 0);
assertEquals(nodes[4].splitValue, nodes[6].getMin().get(0), 0);
assertEquals(3.0, nodes[5].getMin().get(0), 0);
}
// 4
// |--------------- y = 2
// 1 | 2 3
// x = 1
// total space is from (0,0) to (4,4)
private static NDTreeNode[] getNDTreeNodes2D() {
NDTreeNode parent = new NDTreeNode();
parent.setAxisIndex(0);
parent.setSplitValue(1.0);
parent.setLeftChild(1);
parent.setRightChild(2);
NDTreeNode one = new NDTreeNode();
one.setAxisIndex(LEAF);
one.setMin(Arrays.asList(0.0,0.0));
one.setMax(Arrays.asList(1.0,4.0));
NDTreeNode two = new NDTreeNode();
two.setAxisIndex(1);
two.setSplitValue(2.0);
two.setLeftChild(3);
two.setRightChild(4);
NDTreeNode three = new NDTreeNode();
three.setAxisIndex(LEAF);
three.setMin(Arrays.asList(1.0,0.0));
three.setMax(Arrays.asList(4.0,2.0));
NDTreeNode four = new NDTreeNode();
four.setAxisIndex(LEAF);
four.setMin(Arrays.asList(1.0,2.0));
four.setMax(Arrays.asList(4.0,4.0));
return new NDTreeNode[]{parent, one, two, three, four};
}
public static NDTreeModel getNDTreeModel() {
return new NDTreeModel(getNDTreeNodes2D());
}
public static NDTreeModel getNDTreeModel2DWithSameMinMax() {
NDTreeNode parent = new NDTreeNode();
parent.setAxisIndex(0);
parent.setSplitValue(1.0);
parent.setLeftChild(1);
parent.setRightChild(2);
NDTreeNode one = new NDTreeNode();
one.setAxisIndex(LEAF);
one.setMin(Arrays.asList(0.0,0.0));
one.setMax(Arrays.asList(0.0,4.0));
NDTreeNode two = new NDTreeNode();
two.setAxisIndex(1);
two.setSplitValue(2.0);
two.setLeftChild(3);
two.setRightChild(4);
NDTreeNode three = new NDTreeNode();
three.setAxisIndex(LEAF);
three.setMin(Arrays.asList(1.0,0.0));
three.setMax(Arrays.asList(4.0,2.0));
NDTreeNode four = new NDTreeNode();
four.setAxisIndex(LEAF);
four.setMin(Arrays.asList(4.0,4.0));
four.setMax(Arrays.asList(4.0,4.0));
NDTreeNode[] arr = {parent, one, two, three, four};
return new NDTreeModel(arr);
}
public static NDTreeModel getNDTreeModel1DWithSameMinMax() {
NDTreeNode parent = new NDTreeNode();
parent.setAxisIndex(0);
parent.setSplitValue(2.0);
parent.setLeftChild(1);
parent.setRightChild(2);
NDTreeNode one = new NDTreeNode();
one.setAxisIndex(LEAF);
one.setMin(Arrays.asList(1.0));
one.setMax(Arrays.asList(1.0));
NDTreeNode two = new NDTreeNode();
two.setAxisIndex(0);
two.setSplitValue(2.5);
two.setLeftChild(3);
two.setRightChild(4);
NDTreeNode three = new NDTreeNode();
three.setAxisIndex(LEAF);
three.setMin(Arrays.asList(2.0));
three.setMax(Arrays.asList(2.0));
NDTreeNode four = new NDTreeNode();
four.setAxisIndex(LEAF);
four.setMin(Arrays.asList(3.0));
four.setMax(Arrays.asList(3.0));
NDTreeNode[] arr = {parent, one, two, three, four};
return new NDTreeModel(arr);
}
public static NDTreeModel getNDTreeModel1D() {
NDTreeNode parent = new NDTreeNode();
parent.setAxisIndex(0);
parent.setSplitValue(1.0);
parent.setLeftChild(1);
parent.setRightChild(2);
NDTreeNode one = new NDTreeNode();
one.setAxisIndex(LEAF);
one.setMin(Arrays.asList(0.0));
one.setMax(Arrays.asList(1.0));
NDTreeNode two = new NDTreeNode();
two.setAxisIndex(0);
two.setSplitValue(2.0);
two.setLeftChild(3);
two.setRightChild(4);
NDTreeNode three = new NDTreeNode();
three.setAxisIndex(LEAF);
three.setMin(Arrays.asList(1.0));
three.setMax(Arrays.asList(2.0));
NDTreeNode four = new NDTreeNode();
four.setAxisIndex(LEAF);
four.setMin(Arrays.asList(2.0));
four.setMax(Arrays.asList(4.0));
NDTreeNode[] arr = {parent, one, two, three, four};
return new NDTreeModel(arr);
}
@Test
public void testDimension() {
NDTreeModel tree = getNDTreeModel();
assertEquals(2, tree.getDimension());
NDTreeNode parent = new NDTreeNode();
parent.setAxisIndex(0);
NDTreeNode one = new NDTreeNode();
one.setAxisIndex(3);
NDTreeNode[] arr = {parent, one};
tree = new NDTreeModel(arr);
assertEquals(4, tree.getDimension());
tree = NDTreeModelTest.getNDTreeModel1D();
assertEquals(1, tree.getDimension());
}
@Test
public void testLeaf() {
NDTreeModel tree = getNDTreeModel();
int leaf = tree.leaf(-1, -1);
assertEquals(1, leaf);
leaf = tree.leaf(Arrays.asList((float) -1, (float) -1));
assertEquals(1, leaf);
leaf = tree.leaf((float)1.1, (float)0.0);
assertEquals(3, leaf);
leaf = tree.leaf(Arrays.asList((float)1.1, (float)0.0));
assertEquals(3, leaf);
leaf = tree.leaf((float)1.0, (float)2.0);
assertEquals(4, leaf);
leaf = tree.leaf(Arrays.asList(1.0, 2.0));
assertEquals(4, leaf);
leaf = tree.leaf((float)0.99, (float)2.1);
assertEquals(1, leaf);
leaf = tree.leaf(Arrays.asList(0.99, 2.1));
assertEquals(1, leaf);
}
@Test
public void testQuery() {
NDTreeModel tree = getNDTreeModel();
List<Integer> res1 = tree.query((float)-1.0, (float)-1.0);
assertEquals(2, res1.size());
assertEquals(0, res1.get(0).intValue());
assertEquals(1, res1.get(1).intValue());
tree.query(Arrays.asList((float)-1.0, (float)-1.0));
assertEquals(2, res1.size());
assertEquals(0, res1.get(0).intValue());
assertEquals(1, res1.get(1).intValue());
List<Integer> res2 = tree.query((float)1.1, (float)0.0);
assertEquals(3, res2.size());
assertEquals(0, res2.get(0).intValue());
assertEquals(2, res2.get(1).intValue());
assertEquals(3, res2.get(2).intValue());
res2 = tree.query(Arrays.asList((float)1.1, (float)0.0));
assertEquals(3, res2.size());
assertEquals(0, res2.get(0).intValue());
assertEquals(2, res2.get(1).intValue());
assertEquals(3, res2.get(2).intValue());
List<Integer> res3 = tree.query((float)1.0, (float)2.0);
assertEquals(3, res3.size());
assertEquals(0, res3.get(0).intValue());
assertEquals(2, res3.get(1).intValue());
assertEquals(4, res3.get(2).intValue());
res3 = tree.query(Arrays.asList((float)1.0, (float)2.0));
assertEquals(3, res3.size());
assertEquals(0, res3.get(0).intValue());
assertEquals(2, res3.get(1).intValue());
assertEquals(4, res3.get(2).intValue());
List<Integer> res4 = tree.query((float)0.99, (float)2.1);
assertEquals(2, res4.size());
assertEquals(0, res4.get(0).intValue());
assertEquals(1, res4.get(1).intValue());
res4 = tree.query(Arrays.asList((float)0.99, (float)2.1));
assertEquals(2, res4.size());
assertEquals(0, res4.get(0).intValue());
assertEquals(1, res4.get(1).intValue());
}
private Set<Integer> toSet(List<Integer> arr) {
Set<Integer> set = new HashSet<>();
for (Integer i : arr) {
set.add(i);
}
return set;
}
@Test
public void testQueryBox() {
NDTreeModel tree = getNDTreeModel();
// This box covers all nodes
Set<Integer> q1 = toSet(tree.queryBox(Arrays.asList(-10.0, -10.0), Arrays.asList(10.0, 10.0)));
assertEquals(q1.size(), 5);
assertTrue(q1.contains(0));
assertTrue(q1.contains(1));
assertTrue(q1.contains(2));
assertTrue(q1.contains(3));
assertTrue(q1.contains(4));
// This box covers only nodes 0 and 1
Set<Integer> q2 = toSet(tree.queryBox(Arrays.asList(-10.0, -10.0), Arrays.asList(0.9, 10.0)));
assertEquals(q2.size(), 2);
assertTrue(q2.contains(0));
assertTrue(q2.contains(1));
// This box covers only nodes 0, 1, 2, 4
Set<Integer> q3 = toSet(tree.queryBox(Arrays.asList(-10.0, 2.0), Arrays.asList(2.0, 10.0)));
assertEquals(q3.size(), 4);
assertTrue(q3.contains(0));
assertTrue(q3.contains(1));
assertTrue(q3.contains(2));
assertTrue(q3.contains(4));
// This box covers only node 0, 2, 3
Set<Integer> q4 = toSet(tree.queryBox(Arrays.asList(1.1, 0.0), Arrays.asList(10.0, 1.9)));
assertEquals(q4.size(), 3);
assertTrue(q4.contains(0));
assertTrue(q4.contains(2));
assertTrue(q4.contains(3));
// This box covers all nodes except 1
Set<Integer> q5 = toSet(tree.queryBox(Arrays.asList(1.0, 0.0), Arrays.asList(10.0, 2.0)));
assertEquals(q5.size(), 4);
assertTrue(q5.contains(0));
assertTrue(q5.contains(2));
assertTrue(q5.contains(3));
assertTrue(q5.contains(4));
}
}
| 7,112 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/models/LinearModelTest.java | package com.airbnb.aerosolve.core.models;
import com.airbnb.aerosolve.core.DebugScoreRecord;
import com.airbnb.aerosolve.core.FeatureVector;
import com.airbnb.aerosolve.core.ModelHeader;
import com.airbnb.aerosolve.core.ModelRecord;
import com.airbnb.aerosolve.core.util.Util;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.HashSet;
import java.util.HashMap;
import com.google.common.hash.HashCode;
import com.google.common.base.Optional;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class LinearModelTest {
private static final Logger log = LoggerFactory.getLogger(LinearModelTest.class);
public FeatureVector makeFeatureVector() {
Set list = new HashSet<String>();
list.add("aaa");
list.add("bbb");
// add a feature that is missing in the model
list.add("ccc");
HashMap stringFeatures = new HashMap<String, ArrayList<String>>();
stringFeatures.put("string_feature", list);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
return featureVector;
}
public LinearModel makeLinearModel() {
LinearModel model = new LinearModel();
Map<String, Map<String, Float>> weights = new HashMap<>();
Map<String, Float> inner = new HashMap<>();
weights.put("string_feature", inner);
inner.put("aaa", 0.5f);
inner.put("bbb", 0.25f);
model.setWeights(weights);
model.setOffset(0.5f);
model.setSlope(1.5f);
return model;
}
@Test
public void testScoreEmptyFeature() {
FeatureVector featureVector = new FeatureVector();
LinearModel model = new LinearModel();
float score = model.scoreItem(featureVector);
assertTrue(score < 1e-10f);
assertTrue(score > -1e-10f);
}
@Test
public void testScoreNonEmptyFeature() {
FeatureVector featureVector = makeFeatureVector();
LinearModel model = new LinearModel();
Map<String, Map<String, Float>> weights = new HashMap<>();
Map<String, Float> inner = new HashMap<>();
weights.put("string_feature", inner);
inner.put("aaa", 0.5f);
inner.put("bbb", 0.25f);
model.setWeights(weights);
float score = model.scoreItem(featureVector);
assertTrue(score < 0.76f);
assertTrue(score > 0.74f);
}
@Test
public void testLoad() {
CharArrayWriter charWriter = new CharArrayWriter();
BufferedWriter writer = new BufferedWriter(charWriter);
ModelHeader header = new ModelHeader();
header.setModelType("linear");
header.setNumRecords(1);
ModelRecord record1 = new ModelRecord();
record1.setModelHeader(header);
ModelRecord record2 = new ModelRecord();
record2.setFeatureFamily("string_feature");
record2.setFeatureName("bbb");
record2.setFeatureWeight(0.9f);
try {
writer.write(Util.encode(record1) + "\n");
writer.write(Util.encode(record2) + "\n");
writer.close();
} catch (IOException e) {
assertTrue("Could not write", false);
}
String serialized = charWriter.toString();
assertTrue(serialized.length() > 0);
StringReader strReader = new StringReader(serialized);
BufferedReader reader = new BufferedReader(strReader);
FeatureVector featureVector = makeFeatureVector();
try {
Optional<AbstractModel> model = ModelFactory.createFromReader(reader);
assertTrue(model.isPresent());
float score = model.get().scoreItem(featureVector);
assertTrue(score > 0.89f);
assertTrue(score < 0.91f);
} catch (IOException e) {
assertTrue("Could not read", false);
}
}
@Test
public void testSave() {
StringWriter strWriter = new StringWriter();
BufferedWriter writer = new BufferedWriter(strWriter);
LinearModel model = makeLinearModel();
try {
model.save(writer);
writer.close();
} catch (IOException e) {
assertTrue("Could not save", false);
}
}
@Test
public void testDebugScoreComponents() {
LinearModel model = makeLinearModel();
FeatureVector fv = makeFeatureVector();
List<DebugScoreRecord> scoreRecordsList = model.debugScoreComponents(fv);
assertTrue(scoreRecordsList.size() == 2);
for (DebugScoreRecord record : scoreRecordsList) {
assertTrue(record.featureFamily == "string_feature");
assertTrue(record.featureName == "aaa" || record.featureName == "bbb");
assertTrue(record.featureValue == 1.0);
if (record.featureName == "aaa") {
assertTrue(record.featureWeight == 0.5f);
} else {
assertTrue(record.featureWeight == 0.25f);
}
}
}
} | 7,113 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/models/AdditiveModelTest.java | package com.airbnb.aerosolve.core.models;
import com.airbnb.aerosolve.core.FeatureVector;
import com.airbnb.aerosolve.core.ModelHeader;
import com.airbnb.aerosolve.core.ModelRecord;
import com.airbnb.aerosolve.core.FunctionForm;
import com.airbnb.aerosolve.core.function.Function;
import com.airbnb.aerosolve.core.function.Linear;
import com.airbnb.aerosolve.core.function.Spline;
import com.airbnb.aerosolve.core.util.Util;
import com.google.common.base.Optional;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.CharArrayWriter;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.assertEquals;
/**
* Test the additive model
*/
public class AdditiveModelTest {
private static final Logger log = LoggerFactory.getLogger(AdditiveModelTest.class);
AdditiveModel makeAdditiveModel() {
AdditiveModel model = new AdditiveModel();
Map<String, Map<String, Function>> weights = new HashMap<>();
Map<String, Function> innerSplineFloat = new HashMap<String, Function>();
Map<String, Function> innerLinearFloat = new HashMap<String, Function>();
Map<String, Function> innerSplineString = new HashMap<String, Function>();
Map<String, Function> innerLinearString = new HashMap<String, Function>();
weights.put("spline_float", innerSplineFloat);
weights.put("linear_float", innerLinearFloat);
weights.put("spline_string", innerSplineString);
weights.put("linear_string", innerLinearString);
float [] ws = {5.0f, 10.0f, -20.0f};
innerSplineFloat.put("aaa", new Spline(1.0f, 3.0f, ws));
// for string feature, only the first element in weight is meaningful.
innerSplineString.put("bbb", new Spline(1.0f, 2.0f, ws));
float [] wl = {1.0f, 2.0f};
innerLinearFloat.put("ccc", new Linear(-10.0f, 5.0f, wl));
innerLinearString.put("ddd", new Linear(1.0f, 1.0f, wl));
model.setWeights(weights);
model.setOffset(0.5f);
model.setSlope(1.5f);
return model;
}
public FeatureVector makeFeatureVector(float a, float c) {
FeatureVector featureVector = new FeatureVector();
HashMap stringFeatures = new HashMap<String, HashSet<String>>();
featureVector.setStringFeatures(stringFeatures);
HashMap floatFeatures = new HashMap<String, HashMap<String, Double>>();
featureVector.setFloatFeatures(floatFeatures);
// prepare string features
Set list1 = new HashSet<String>();
list1.add("bbb"); // weight = 5.0f
list1.add("ggg"); // this feature is missing in the model
stringFeatures.put("spline_string", list1);
Set list2 = new HashSet<String>();
list2.add("ddd"); // weight = 3.0f
list2.add("ggg"); // this feature is missing in the model
stringFeatures.put("linear_string", list2);
featureVector.setStringFeatures(stringFeatures);
// prepare float features
HashMap splineFloat = new HashMap<String, Double>();
HashMap linearFloat = new HashMap<String, Double>();
floatFeatures.put("spline_float", splineFloat);
floatFeatures.put("linear_float", linearFloat);
splineFloat.put("aaa", (double) a); // corresponds to Spline(1.0f, 3.0f, {5, 10, -20})
splineFloat.put("ggg", 1.0); // missing features
linearFloat.put("ccc", (double) c); // weight = 1+2*c
linearFloat.put("ggg", 10.0); // missing features
return featureVector;
}
@Test
public void testScoreEmptyFeature() {
FeatureVector featureVector = new FeatureVector();
AdditiveModel model = new AdditiveModel();
float score = model.scoreItem(featureVector);
assertEquals(0.0f, score, 1e-10f);
}
@Test
public void testScoreNonEmptyFeature() {
AdditiveModel model = makeAdditiveModel();
FeatureVector fv1 = makeFeatureVector(1.0f, 0.0f);
float score1 = model.scoreItem(fv1);
assertEquals(8.0f + 5.0f + (1.0f + 2.0f * (0.0f + 10.0f) / 15.0f), score1, 0.001f);
FeatureVector fv2 = makeFeatureVector(-1.0f, 0.0f);
float score2 = model.scoreItem(fv2);
assertEquals(8.0f + 5.0f + (1.0f + 2.0f * (0.0f + 10.0f) / 15.0f), score2, 0.001f);
FeatureVector fv3 = makeFeatureVector(4.0f, 1.0f);
float score3 = model.scoreItem(fv3);
assertEquals(8.0f - 20.0f + (1.0f + 2.0f * (1.0f + 10.0f) / 15.0f), score3, 0.001f);
FeatureVector fv4 = makeFeatureVector(2.0f, 7.0f);
float score4 = model.scoreItem(fv4);
assertEquals(8.0f + 10.0f + (1.0f + 2.0f * (7.0f + 10.0f) / 15.0f), score4, 0.001f);
}
@Test
public void testLoad() {
CharArrayWriter charWriter = new CharArrayWriter();
BufferedWriter writer = new BufferedWriter(charWriter);
ModelHeader header = new ModelHeader();
header.setModelType("additive");
header.setNumRecords(4);
ArrayList<Double> ws = new ArrayList<Double>();
ws.add(5.0);
ws.add(10.0);
ws.add(-20.0);
ArrayList<Double> wl = new ArrayList<Double>();
wl.add(1.0);
wl.add(2.0);
ModelRecord record1 = new ModelRecord();
record1.setModelHeader(header);
ModelRecord record2 = new ModelRecord();
record2.setFunctionForm(FunctionForm.Spline);
record2.setFeatureFamily("spline_float");
record2.setFeatureName("aaa");
record2.setWeightVector(ws);
record2.setMinVal(1.0);
record2.setMaxVal(3.0);
ModelRecord record3 = new ModelRecord();
record3.setFunctionForm(FunctionForm.Spline);
record3.setFeatureFamily("spline_string");
record3.setFeatureName("bbb");
record3.setWeightVector(ws);
record3.setMinVal(1.0);
record3.setMaxVal(2.0);
ModelRecord record4 = new ModelRecord();
record4.setFunctionForm(FunctionForm.Linear);
record4.setFeatureFamily("linear_float");
record4.setFeatureName("ccc");
record4.setWeightVector(wl);
ModelRecord record5 = new ModelRecord();
record5.setFunctionForm(FunctionForm.Linear);
record5.setFeatureFamily("linear_string");
record5.setFeatureName("ddd");
record5.setWeightVector(wl);
try {
writer.write(Util.encode(record1) + "\n");
writer.write(Util.encode(record2) + "\n");
writer.write(Util.encode(record3) + "\n");
writer.write(Util.encode(record4) + "\n");
writer.write(Util.encode(record5) + "\n");
writer.close();
} catch (IOException e) {
assertTrue("Could not write", false);
}
String serialized = charWriter.toString();
assertTrue(serialized.length() > 0);
StringReader strReader = new StringReader(serialized);
BufferedReader reader = new BufferedReader(strReader);
FeatureVector featureVector = makeFeatureVector(2.0f, 7.0f);
try {
Optional<AbstractModel> model = ModelFactory.createFromReader(reader);
assertTrue(model.isPresent());
float score = model.get().scoreItem(featureVector);
assertEquals(8.0f + 10.0f + 15.0f, score, 0.001f);
} catch (IOException e) {
assertTrue("Could not read", false);
}
}
@Test
public void testSave() {
StringWriter strWriter = new StringWriter();
BufferedWriter writer = new BufferedWriter(strWriter);
AdditiveModel model = makeAdditiveModel();
try {
model.save(writer);
writer.close();
} catch (IOException e) {
assertTrue("Could not save", false);
}
}
@Test
public void testAddFunction() {
AdditiveModel model = makeAdditiveModel();
// add an existing feature without overwrite
model.addFunction("spline_float", "aaa", new Spline(2.0f, 10.0f, 5), false);
// add an existing feature with overwrite
model.addFunction("linear_float", "ccc", new Linear(3.0f, 5.0f), true);
// add a new feature
model.addFunction("spline_float", "new", new Spline(2.0f, 10.0f, 5), false);
Map<String, Map<String, Function>> weights = model.getWeights();
for (Map.Entry<String, Map<String, Function>> featureFamily: weights.entrySet()) {
String familyName = featureFamily.getKey();
Map<String, Function> features = featureFamily.getValue();
for (Map.Entry<String, Function> feature: features.entrySet()) {
String featureName = feature.getKey();
Function func = feature.getValue();
if (familyName.equals("spline_float")) {
Spline spline = (Spline) func;
if (featureName.equals("aaa")) {
assertTrue(spline.getMaxVal() == 3.0f);
assertTrue(spline.getMinVal() == 1.0f);
assertTrue(spline.getWeights().length == 3);
} else if (featureName.equals("new")) {
assertTrue(spline.getMaxVal() == 10.0f);
assertTrue(spline.getMinVal() == 2.0f);
assertTrue(spline.getWeights().length == 5);
}
} else if(familyName.equals("linear_float") && featureName.equals("ccc")) {
Linear linear = (Linear) func;
assertTrue(linear.getWeights().length == 2);
assertTrue(linear.getWeights()[0] == 0.0f);
assertTrue(linear.getWeights()[1] == 0.0f);
assertTrue(linear.getMinVal() == 3.0f);
assertTrue(linear.getMaxVal() == 5.0f);
}
}
}
}
@Test
public void testModelClone() throws CloneNotSupportedException {
float[] weights = {5.0f, 10.0f, -20.0f};
AdditiveModel model = makeAdditiveModel();
model.addFunction("spline_float", "aaa", new Spline(2.0f, 10.0f, weights), false);
AdditiveModel modelClone = model.clone();
modelClone.getWeights().get("spline_float").get("aaa").resample(2);
assertArrayEquals(((Spline)model.getWeights().get("spline_float").get("aaa")).getWeights(), weights, 0);
}
}
| 7,114 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/function/LinearTest.java | package com.airbnb.aerosolve.core.function;
import com.airbnb.aerosolve.core.ModelRecord;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
/**
* Test linear function
*/
public class LinearTest {
private float func(float x) {
return 0.2f + 1.5f * (x + 6.0f) / 11.0f;
}
private Linear createLinearTestExample() {
float [] weights = {0.2f, 1.5f};
return new Linear(-6.0f, 5.0f, weights);
}
@Test
public void testLinearEvaluate() {
Linear linearFunc = createLinearTestExample();
testLinear(linearFunc);
}
@Test
public void testLinearModelRecordConstructor() {
ModelRecord record = new ModelRecord();
record.setFeatureFamily("TEST");
record.setFeatureName("a");
List<Double> weightVec = new ArrayList<>();
weightVec.add(0.2);
weightVec.add(1.5);
record.setWeightVector(weightVec);
record.setMinVal(-6.0f);
record.setMaxVal(5.0f);
Linear linearFunc = new Linear(record);
testLinear(linearFunc);
}
@Test
public void testLinearToModelRecord() {
Linear linearFunc = createLinearTestExample();
ModelRecord record = linearFunc.toModelRecord("family", "name");
assertEquals(record.getFeatureFamily(), "family");
assertEquals(record.getFeatureName(), "name");
List<Double> weightVector = record.getWeightVector();
assertEquals(0.2f, weightVector.get(0).floatValue(), 0.01f);
assertEquals(1.5f, weightVector.get(1).floatValue(), 0.01f);
assertEquals(-6.0f, record.getMinVal(), 0.01f);
assertEquals(5.0f, record.getMaxVal(), 0.01f);
}
@Test
public void testLinearUpdate() {
Linear linearFunc = new Linear(-6.0f, 5.0f, new float[2]);
Random rnd = new java.util.Random(123);
for (int i = 0; i < 1000; i++) {
float x = (float) (rnd.nextDouble() * 10.0 - 5.0);
float y = func(x);
float tmp = linearFunc.evaluate(x);
float delta = 0.5f * (y - tmp);
linearFunc.update(delta, x);
}
testLinear(linearFunc);
}
@Test
public void testLinearClone() throws CloneNotSupportedException {
Linear linearFunc = new Linear(-6.0f, 5.0f, new float[2]);
Linear linearCopy = linearFunc.clone();
linearCopy.weights = new float[]{1.0f, 2.0f, 3.0f};
assertArrayEquals(linearFunc.weights, new float[2], 0);
linearCopy.minVal = 0f;
assertEquals(linearFunc.minVal, -6f, 0);
}
private void testLinear(Linear linearFunc) {
assertEquals(0.2f + 1.5f * 6.0f / 11.0f, linearFunc.evaluate(0.0f), 0.01f);
assertEquals(0.2f + 1.5f * 7.0f / 11.0f, linearFunc.evaluate(1.0f), 0.01f);
assertEquals(0.2f + 1.5f * 5.0f / 11.0f, linearFunc.evaluate(-1.0f), 0.01f);
}
}
| 7,115 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/function/SplineTest.java | package com.airbnb.aerosolve.core.function;
import com.airbnb.aerosolve.core.ModelRecord;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
/**
* @author Hector Yee
*/
@Slf4j
public class SplineTest {
@Test
public void testSplineEvaluate() {
float[] weights = {5.0f, 10.0f, -20.0f};
Spline spline = new Spline(1.0f, 3.0f, weights);
testSpline(spline, 0.1f);
}
public static Spline getSpline() {
float[] weights = {5.0f, 10.0f, -20.0f};
return new Spline(1.0f, 3.0f, weights);
}
@Test
public void testSplineResampleConstructor() {
Spline spline = getSpline();
// Same size
spline.resample(3);
testSpline(spline, 0.1f);
// Smaller
Spline spline3 = getSpline();
spline3.resample(2);
assertEquals(5.0f, spline3.evaluate(-1.0f), 0.1f);
assertEquals(5.0f, spline3.evaluate(1.0f), 0.1f);
assertEquals((5.0f - 20.0f) * 0.5f, spline3.evaluate(2.0f), 0.1f);
assertEquals(-20.0f, spline3.evaluate(3.0f), 0.1f);
assertEquals(-20.0f, spline3.evaluate(4.0f), 0.1f);
// Larger
Spline spline4 = getSpline();
spline4.resample(100);
testSpline(spline4, 0.2f);
}
@Test
public void testSplineModelRecordConstructor() {
ModelRecord record = new ModelRecord();
record.setFeatureFamily("TEST");
record.setFeatureName("a");
record.setMinVal(1.0);
record.setMaxVal(3.0);
List<Double> weightVec = new ArrayList<Double>();
weightVec.add(5.0);
weightVec.add(10.0);
weightVec.add(-20.0);
record.setWeightVector(weightVec);
Spline spline = new Spline(record);
testSpline(spline, 0.1f);
}
@Test
public void testSplineToModelRecord() {
float[] weights = {5.0f, 10.0f, -20.0f};
Spline spline = new Spline(1.0f, 3.0f, weights);
ModelRecord record = spline.toModelRecord("family", "name");
assertEquals(record.getFeatureFamily(), "family");
assertEquals(record.getFeatureName(), "name");
List<Double> weightVector = record.getWeightVector();
assertEquals(5.0f, weightVector.get(0).floatValue(), 0.01f);
assertEquals(10.0f, weightVector.get(1).floatValue(), 0.01f);
assertEquals(-20.0f, weightVector.get(2).floatValue(), 0.01f);
assertEquals(1.0f, record.getMinVal(), 0.01f);
assertEquals(3.0f, record.getMaxVal(), 0.01f);
}
@Test
public void testSplineResample() {
float[] weights = {5.0f, 10.0f, -20.0f};
// Same size
Spline spline1 = new Spline(1.0f, 3.0f, weights);
spline1.resample(3);
testSpline(spline1, 0.1f);
// Smaller
Spline spline2 = new Spline(1.0f, 3.0f, weights);
spline2.resample(2);
assertEquals(5.0f, spline2.evaluate(-1.0f), 0.1f);
assertEquals(5.0f, spline2.evaluate(1.0f), 0.1f);
assertEquals((5.0f - 20.0f) * 0.5f, spline2.evaluate(2.0f), 0.1f);
assertEquals(-20.0f, spline2.evaluate(3.0f), 0.1f);
assertEquals(-20.0f, spline2.evaluate(4.0f), 0.1f);
// Larger
Spline spline3 = new Spline(1.0f, 3.0f, weights);
spline3.resample(100);
testSpline(spline3, 0.2f);
spline3.resample(200);
testSpline(spline3, 0.2f);
}
void testSpline(Spline spline, float tol) {
float a = spline.evaluate(1.5f);
log.info("spline 1.5 is " + a);
assertEquals(5.0f, spline.evaluate(-1.0f), tol);
assertEquals(5.0f, spline.evaluate(1.0f), tol);
assertEquals(7.5f, spline.evaluate(1.5f), tol);
assertEquals(10.0f, spline.evaluate(1.99f), tol);
assertEquals(10.0f, spline.evaluate(2.0f), tol);
assertEquals(0.0f, spline.evaluate(2.3333f), tol);
assertEquals(-10.0f, spline.evaluate(2.667f), tol);
assertEquals(-20.0f, spline.evaluate(2.99999f), tol);
assertEquals(-20.0f, spline.evaluate(3.0f), tol);
assertEquals(-20.0f, spline.evaluate(4.0f), tol);
}
float func(float x) {
return 0.1f * (x + 0.5f) * (x - 4.0f) * (x - 1.0f);
}
@Test
public void testSplineUpdate() {
float[] weights = new float[8];
Spline spline = new Spline(-1.0f, 5.0f, weights);
Random rnd = new java.util.Random(123);
for (int i = 0; i < 1000; i++) {
float x = (float) (rnd.nextDouble() * 6.0 - 1.0);
float y = func(x);
float tmp = spline.evaluate(x);
float delta =0.1f * (y - tmp);
spline.update(delta, x);
}
// Check we get roots where we expect them to be.
assertEquals(0.0f, spline.evaluate(-0.5f), 0.1f);
assertEquals(0.0f, spline.evaluate(1.0f), 0.1f);
assertEquals(0.0f, spline.evaluate(4.0f), 0.1f);
for (int i = 0; i < 20; i++) {
float x = (float) (6.0 * i / 20.0 - 1.0f);
float expected = func(x);
float eval = spline.evaluate(x);
log.info("x = " + x + " expected = " + expected + " got = " + eval);
assertEquals(expected, spline.evaluate(x), 0.1f);
}
}
@Test
public void testSplineL1Norm() {
float[] weights1 = {5.0f, 10.0f, -20.0f};
Spline spline1 = new Spline(1.0f, 3.0f, weights1);
assertEquals(35.0f, spline1.L1Norm(), 0.01f);
float[] weights2 = {0.0f, 0.0f};
Spline spline2 = new Spline(1.0f, 3.0f, weights2);
assertEquals(0.0f, spline2.L1Norm(), 0.01f);
}
@Test
public void testSplineLInfinityNorm() {
float[] weights1 = {5.0f, 10.0f, -20.0f};
Spline spline1 = new Spline(1.0f, 3.0f, weights1);
assertEquals(20.0f, spline1.LInfinityNorm(), 0.01f);
float[] weights2 = {0.0f, 0.0f};
Spline spline2 = new Spline(1.0f, 3.0f, weights2);
assertEquals(0.0f, spline2.LInfinityNorm(), 0.01f);
}
@Test
public void testSplineLInfinityCap() {
float[] weights = {5.0f, 10.0f, -20.0f};
Spline spline1 = new Spline(1.0f, 3.0f, weights);
// Larger (no scale)
spline1.LInfinityCap(30.0f);
assertEquals(5.0f, spline1.getWeights()[0], 0.01f);
assertEquals(10.0f, spline1.getWeights()[1], 0.01f);
assertEquals(-20.0f, spline1.getWeights()[2], 0.01f);
// Negative
spline1.LInfinityCap(-10.0f);
assertEquals(5.0f, spline1.getWeights()[0], 0.01f);
assertEquals(10.0f, spline1.getWeights()[1], 0.01f);
assertEquals(-20.0f, spline1.getWeights()[2], 0.01f);
// Smaller (with scale)
Spline spline2 = new Spline(1.0f, 3.0f, weights);
spline2.LInfinityCap(10.0f);
float scale = 10.0f / 20.0f;
assertEquals(5.0f * scale, spline2.getWeights()[0], 0.01f);
assertEquals(10.0f * scale, spline2.getWeights()[1], 0.01f);
assertEquals(-20.0f * scale, spline2.getWeights()[2], 0.01f);
}
@Test
public void testSplineClone() throws CloneNotSupportedException {
float[] weights = {5.0f, 10.0f, -20.0f};
Spline spline = new Spline(1.0f, 3.0f, weights);
Spline splineCopy = spline.clone();
splineCopy.resample(2);
assertArrayEquals(spline.weights, weights, 0);
splineCopy.minVal = 0f;
assertEquals(spline.minVal, 1f, 0);
}
}
| 7,116 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/function/MultiDimensionSplineTest.java | package com.airbnb.aerosolve.core.function;
import com.airbnb.aerosolve.core.ModelRecord;
import com.airbnb.aerosolve.core.models.NDTreeModel;
import com.airbnb.aerosolve.core.models.NDTreeModelTest;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
@Slf4j
public class MultiDimensionSplineTest {
public MultiDimensionSpline getMultiDimensionSpline() {
NDTreeModel tree = NDTreeModelTest.getNDTreeModel();
return new MultiDimensionSpline(tree);
}
public MultiDimensionSpline getMultiDimensionSpline1D() {
NDTreeModel tree = NDTreeModelTest.getNDTreeModel1D();
return new MultiDimensionSpline(tree);
}
@Test
public void evaluate() throws Exception {
MultiDimensionSpline spline = getMultiDimensionSpline();
eval(spline);
}
@Test
public void evaluate1DWithSameMinMax() throws Exception {
NDTreeModel tree = NDTreeModelTest.getNDTreeModel1DWithSameMinMax();
MultiDimensionSpline spline = new MultiDimensionSpline(tree);
spline.update(0.5f, 1.0f);
log.debug("s {}", spline.evaluate(1.0f));
assertEquals(0.5f, spline.evaluate(1.0f), 0);
spline.update(0.5f, 2.0f);
log.info("s {}", spline.evaluate(2.0f));
assertEquals(0.5f, spline.evaluate(2.0f), 0);
spline.update(-0.5f, 1.0f);
log.info("s {}", spline.evaluate(1.0f));
assertEquals(0, spline.evaluate(1.0f), 0);
spline.update(0.5f, 1.0f);
log.info("s {}", spline.evaluate(0.5f));
assertEquals(0.5f, spline.evaluate(0.5f), 0);
}
@Test
public void evaluate2DWithSameMinMax() throws Exception {
NDTreeModel tree = NDTreeModelTest.getNDTreeModel2DWithSameMinMax();
MultiDimensionSpline spline = new MultiDimensionSpline(tree);
spline.update(0.5f, 0.0f, 2.0f);
assertEquals(0.25f, spline.evaluate(0.0f, 1.0f), 0);
assertEquals(0.25f, spline.evaluate(0.5f, 1.0f), 0);
spline.update(0.5f, 2.0f, 1.0f);
assertEquals(0.13133647, spline.evaluate(2.0f, 1.0f), 0.0001);
spline.update(-0.5f, 4.0f, 4.0f);
assertEquals(-0.5, spline.evaluate(4.0f, 4.0f), 0);
}
@Test
public void evaluate1D() throws Exception {
MultiDimensionSpline spline = getMultiDimensionSpline1D();
eval1D(spline);
}
private static void eval1D(MultiDimensionSpline spline) {
spline.update(0.5f, 0.5f);
assertEquals(0.25, spline.evaluate(0.5f), 0.0001);
spline.update(0.8f, 0.6f);
assertEquals(0.65, spline.evaluate(0.5f), 0.0001);
spline.update( 0.8f, 1.5f);
assertEquals(0.685, spline.evaluate(1.5f), 0.0001);
assertEquals(0.1, spline.evaluate(2.5f), 0.0001);
spline.update(0.8f, 3.0f);
assertEquals(0.7, spline.evaluate(3.5f), 0.0001);
}
private static void eval(Function spline) {
spline.update(0.5f, 0.5f, 2.0f);
assertEquals(0.125, spline.evaluate( 0.5f, 2.0f), 0.0001);
spline.update(0.8f, 0.6f, 2.0f);
assertEquals(0.325, spline.evaluate(0.5f, 2.0f), 0.0001);
spline.update( 0.8f, 2.0f, 1.0f);
assertEquals(0.28868586584843375, spline.evaluate(3.0f, 1.0f), 0.0001);
spline.update(0.8f, 3.0f, 3.0f);
assertEquals(0.40389338302461303, spline.evaluate(3.0f, 3.0f), 0.0001);
}
@Test
public void aggregate() throws Exception {
List<Function> splineList = new ArrayList<>();
for (int i = 0; i < 10; ++i) {
MultiDimensionSpline spline = getMultiDimensionSpline();
set(spline);
splineList.add(spline);
}
Function r = splineList.get(0).aggregate(splineList, 0.1f, 0);
assertEquals(0.40389338302461303, r.evaluate(3.0f, 3.0f), 0.0001);
}
private static void set(Function spline) {
spline.update(0.5f, 0.5f, 2.0f);
spline.update(0.8f, 0.6f, 2.0f);
spline.update(0.8f, 2.0f, 1.0f);
spline.update(0.8f, 3.0f, 3.0f);
}
private static void set1D(Function spline) {
spline.update(0.5f, 0.5f);
spline.update(0.8f, 0.6f);
spline.update( 0.8f, 1.5f);
spline.update(0.8f, 3.0f);
}
@Test
public void modelRecord() {
MultiDimensionSpline a = getMultiDimensionSpline();
set(a);
ModelRecord record = a.toModelRecord("","");
MultiDimensionSpline b = new MultiDimensionSpline(record);
assertEquals(0.40389338302461303, a.evaluate(3.0f, 3.0f), 0.0001);
assertEquals(0.40389338302461303, b.evaluate(3.0f, 3.0f), 0.0001);
}
@Test
public void modelRecord1D() {
MultiDimensionSpline a = getMultiDimensionSpline1D();
set1D(a);
ModelRecord record = a.toModelRecord("","");
MultiDimensionSpline b = new MultiDimensionSpline(record);
assertEquals(0.7, a.evaluate(3.5f), 0.0001);
assertEquals(0.7, b.evaluate(3.5f), 0.0001);
}
@Test
public void testLInfinityNorm() {
MultiDimensionSpline a = getMultiDimensionSpline();
set(a);
assertEquals(0.5676819, a.LInfinityNorm(), 0.001);
a.update(-8.8f, 3.0f, 3.0f);
assertEquals(2.2953262329101562, a.LInfinityNorm(), 0.001);
}
@Test
public void testLInfinityCap() {
MultiDimensionSpline a = getMultiDimensionSpline();
set(a);
a.LInfinityCap(0.8f);
assertEquals(0.5676819, a.LInfinityNorm(), 0.001);
a.LInfinityCap(0.5f);
assertEquals(0.5, a.LInfinityNorm(), 0.001);
}
}
| 7,117 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/function/MultiDimensionPointTest.java | package com.airbnb.aerosolve.core.function;
import com.airbnb.aerosolve.core.util.Util;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.junit.Assert.*;
@Slf4j
public class MultiDimensionPointTest {
@Test
public void testEquals() throws Exception {
List<Float> a = Arrays.asList(3.0f, -5.0f, -9.0f);
List<Float> a1 = Arrays.asList(3.0f, -5.0f, -9.0f);
List<Float> b = Arrays.asList(3.0f, -5.0f, 10.0f);
MultiDimensionPoint p1 = new MultiDimensionPoint(a);
MultiDimensionPoint p2 = new MultiDimensionPoint(a1);
assertEquals(p1.hashCode(), p2.hashCode());
assertEquals(p1, p2);
MultiDimensionPoint p3 = new MultiDimensionPoint(b);
assertFalse(p1.hashCode() == p3.hashCode());
assertFalse(p1.equals(p3));
}
@Test
public void getPointFromNDTree() throws Exception {
List<Double> min = Arrays.asList(3.0, -5.0, -9.0);
List<Double> max = Arrays.asList(13.0, 15.0, 10.0);
List<List<Float>> r = Arrays.asList(
Arrays.asList(3.0f, -5.0f, -9.0f),
Arrays.asList(13.0f, -5.0f, -9.0f),
Arrays.asList(3.0f, 15.0f, -9.0f),
Arrays.asList(13.0f, 15.0f, -9.0f),
Arrays.asList(3.0f, -5.0f, 10.0f),
Arrays.asList(13.0f, -5.0f, 10.0f),
Arrays.asList(3.0f, 15.0f, 10.0f),
Arrays.asList(13.0f, 15.0f, 10.0f)
);
Map<List<Float>, MultiDimensionPoint> points = new HashMap<>();
MultiDimensionPoint a = new MultiDimensionPoint(r.get(0));
points.put(r.get(0), a);
MultiDimensionPoint x = new MultiDimensionPoint(r.get(1));
points.put(r.get(1), x);
x.setWeight(0.5);
List<Float> extra = Arrays.asList((float)5.0, (float)15.0, (float)11.0);
points.put(extra, new MultiDimensionPoint(extra));
List<MultiDimensionPoint> result = MultiDimensionPoint.getCombinationWithoutDuplication(min, max, points);
assertEquals(8, result.size());
assertEquals(9, points.size());
assertEquals(a, result.get(0));
assertTrue(a == result.get(0));
MultiDimensionPoint y = result.get(1);
assertEquals(x, y);
assertTrue(x == y);
assertEquals(0.5, y.getWeight(), 0.1);
}
@Test
public void getCombinationWithSameMinMax() throws Exception {
List<Double> min = Arrays.asList(3.0);
List<Double> max = Arrays.asList(3.0);
List<List<Float>> keys = MultiDimensionPoint.getCombination(min, max);
assertEquals(1, keys.size());
assertEquals(3, keys.get(0).get(0), 0);
min = Arrays.asList(3.0, 4.0);
max = Arrays.asList(3.0, 4.0);
keys = MultiDimensionPoint.getCombination(min, max);
assertEquals(1, keys.size());
assertEquals(3, keys.get(0).get(0), 0);
assertEquals(4, keys.get(0).get(1), 0);
min = Arrays.asList(3.0, 3.0);
max = Arrays.asList(3.0, 4.0);
keys = MultiDimensionPoint.getCombination(min, max);
assertEquals(2, keys.size());
assertEquals(3, keys.get(0).get(0), 0);
assertEquals(3, keys.get(0).get(1), 0);
assertEquals(3, keys.get(1).get(0), 0);
assertEquals(4, keys.get(1).get(1), 0);
}
@Test
public void getCombination() throws Exception {
List<Double> min = Arrays.asList(3.0, 5.0);
List<Double> max = Arrays.asList(13.0, 15.0);
List<List<Float>> keys = MultiDimensionPoint.getCombination(min, max);
assertEquals(4, keys.size());
List<List<Float>> r = Arrays.asList(
Arrays.asList(3.0f, 5.0f),
Arrays.asList(13.0f, 5.0f),
Arrays.asList(3.0f, 15.0f),
Arrays.asList(13.0f, 15.0f));
assertEquals(keys, r);
min = Arrays.asList(3.0, -5.0, -9.0);
max = Arrays.asList(13.0, 15.0, 10.0);
keys = MultiDimensionPoint.getCombination(min, max);
assertEquals(8, keys.size());
r = Arrays.asList(
Arrays.asList(3.0f, -5.0f, -9.0f),
Arrays.asList(13.0f, -5.0f, -9.0f),
Arrays.asList(3.0f, 15.0f, -9.0f),
Arrays.asList(13.0f, 15.0f, -9.0f),
Arrays.asList(3.0f, -5.0f, 10.0f),
Arrays.asList(13.0f, -5.0f, 10.0f),
Arrays.asList(3.0f, 15.0f, 10.0f),
Arrays.asList(13.0f, 15.0f, 10.0f)
);
assertEquals(keys, r);
}
@Test
public void testZero() {
float[] af = new float[]{0f, 1f, -2f, 3.4f, 5.0f, -6.7f, 8.9f};
List<Float> al = Arrays.asList(0f, 1f, -2f, 3.4f, 5.0f, -6.7f, 8.9f);
List<Float> b = Arrays.asList(0f, 1.0f, -2.0f, 3.4f, 5.0f, -6.7f, 8.9f);
assertEquals(0, Util.euclideanDistance(af, al), 0);
assertEquals(0, Util.euclideanDistance(af, b), 0);
}
@Test
public void test() {
float[] af = new float[]{1.0f, -2.0f, 3.0f, 4.0f};
float[] bf = new float[]{-5.0f, -6.0f, 7.0f, 8.0f};
List<Float> a = Arrays.asList(1.0f, -2.0f, 3.0f, 4.0f);
List<Float> b = Arrays.asList(-5.0f, -6.0f, 7.0f, 8.0f);
final double expected = Math.sqrt(84);
assertEquals(expected, Util.euclideanDistance(af, b), 0.001);
assertEquals(expected, Util.euclideanDistance(bf, a), 0.001);
}
}
| 7,118 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/function/PointTest.java | package com.airbnb.aerosolve.core.function;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
public class PointTest {
private Point example() {
return new Point(-6.0f);
}
@Test
public void LInfinityCap() throws Exception {
Point point = example();
point.LInfinityCap(3.0f);
assertEquals(-3, point.evaluate(1.0f), 0);
}
@Test
public void ConstantPoint() {
Point point = example();
assertEquals(-6, point.evaluate(1.0f), 0);
assertEquals(-6, point.evaluate(-1.0f), 0);
assertEquals(-6, point.evaluate(0f), 0);
}
}
| 7,119 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/DeleteStringFeatureTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class DeleteStringFeatureTransformTest {
private static final Logger log = LoggerFactory.getLogger(DeleteStringFeatureTransformTest.class);
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("aaa:bbbb");
list.add("bbb");
stringFeatures.put("strFeature1", list);
Map<String, Double> map = new HashMap<>();
map.put("lat", 37.7);
map.put("long", 40.0);
floatFeatures.put("loc", map);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public String makeConfig() {
return "test_delete {\n" +
" transform : delete_string_feature\n" +
" field1 : strFeature1\n" +
" keys : [long,aaa]\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_delete");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_delete");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 1);
Set<String> feat1 = stringFeatures.get("strFeature1");
assertEquals(1, feat1.size());
assertTrue(!feat1.contains("aaa"));
assertTrue(!feat1.contains("aaa:bbbb"));
}
} | 7,120 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/CapFloatTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class CapFloatTransformTest {
private static final Logger log = LoggerFactory.getLogger(CapFloatTransformTest.class);
public String makeConfig() {
return "test_cap {\n" +
" transform : cap_float\n" +
" field1 : loc\n" +
" lower_bound : 1.0\n" +
" upper_bound : 39.0\n" +
" keys : [lat,long,z,aaa]\n" +
"}";
}
public String makeConfigWithOutput() {
return "test_cap {\n" +
" transform : cap_float\n" +
" field1 : loc\n" +
" lower_bound : 1.0\n" +
" upper_bound : 39.0\n" +
" keys : [lat,long,z,aaa]\n" +
" output : new_output \n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_cap");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_cap");
FeatureVector featureVector = TransformTestingHelper.makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 1);
Map<String, Double> feat1 = featureVector.getFloatFeatures().get("loc");
assertEquals(3, feat1.size());
assertEquals(37.7, feat1.get("lat"), 0.1);
assertEquals(39.0, feat1.get("long"), 0.1);
assertEquals(1.0, feat1.get("z"), 0.1);
}
@Test
public void testTransformWithNewOutput() {
Config config = ConfigFactory.parseString(makeConfigWithOutput());
Transform transform = TransformFactory.createTransform(config, "test_cap");
FeatureVector featureVector = TransformTestingHelper.makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 1);
// original feature should not change
Map<String, Double> feat1 = featureVector.getFloatFeatures().get("loc");
assertEquals(3, feat1.size());
assertEquals(37.7, feat1.get("lat"), 0.1);
assertEquals(40.0, feat1.get("long"), 0.1);
assertEquals(-20, feat1.get("z"), 0.1);
// capped features are in a new feature family
assertTrue(featureVector.getFloatFeatures().containsKey("new_output"));
Map<String, Double> feat2 = featureVector.getFloatFeatures().get("new_output");
assertEquals(3, feat2.size());
assertEquals(37.7, feat2.get("lat"), 0.1);
assertEquals(39.0, feat2.get("long"), 0.1);
assertEquals(1.0, feat2.get("z"), 0.1);
}
} | 7,121 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/DeleteFloatFeatureFamilyTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import java.util.HashMap;
import java.util.Map;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
public class DeleteFloatFeatureFamilyTransformTest {
private static final Logger log = LoggerFactory.getLogger(
DeleteFloatFeatureFamilyTransformTest.class);
public String makeConfig() {
return "test_delete_float_feature_family {\n" +
" transform: delete_float_feature_family\n" +
" fields: [F1, F2, F3]" +
"}";
}
public FeatureVector makeFeatureVector() {
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Map<String, Double> family1 = new HashMap<>();
family1.put("A", 1.0);
family1.put("B", 2.0);
Map<String, Double> family2 = new HashMap<>();
family2.put("C", 3.0);
family2.put("D", 4.0);
Map<String, Double> family3 = new HashMap<>();
family3.put("E", 5.0);
family3.put("F", 6.0);
Map<String, Double> family4 = new HashMap<>();
family4.put("G", 7.0);
family4.put("H", 8.0);
floatFeatures.put("F1", family1);
floatFeatures.put("F2", family2);
floatFeatures.put("F3", family3);
floatFeatures.put("F4", family4);
FeatureVector featureVector = new FeatureVector();
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(
config, "test_delete_float_feature_family");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getFloatFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(
config, "test_delete_float_feature_family");
FeatureVector fv = makeFeatureVector();
assertNotNull(fv.getFloatFeatures());
assertTrue(fv.getFloatFeatures().containsKey("F1"));
assertTrue(fv.getFloatFeatures().containsKey("F2"));
assertTrue(fv.getFloatFeatures().containsKey("F3"));
assertTrue(fv.getFloatFeatures().containsKey("F4"));
assertEquals(4, fv.getFloatFeatures().size());
transform.doTransform(fv);
assertNotNull(fv.getFloatFeatures());
assertFalse(fv.getFloatFeatures().containsKey("F1"));
assertFalse(fv.getFloatFeatures().containsKey("F2"));
assertFalse(fv.getFloatFeatures().containsKey("F3"));
assertTrue(fv.getFloatFeatures().containsKey("F4"));
assertEquals(1, fv.getFloatFeatures().size());
}
}
| 7,122 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/QuantizeTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class QuantizeTransformTest {
private static final Logger log = LoggerFactory.getLogger(QuantizeTransformTest.class);
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("bbb");
stringFeatures.put("strFeature1", list);
Map<String, Double> map = new HashMap<>();
map.put("lat", 37.7);
map.put("long", 40.0);
floatFeatures.put("loc", map);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public String makeConfig() {
return "test_quantize {\n" +
" transform : quantize\n" +
" field1 : loc\n" +
" scale : 10\n" +
" output : loc_quantized\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_quantize");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_quantize");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 2);
Set<String> out = stringFeatures.get("loc_quantized");
assertTrue(out.size() == 2);
log.info("quantize output");
for (String string : out) {
log.info(string);
}
assertTrue(out.contains("lat=377"));
assertTrue(out.contains("long=400"));
}
} | 7,123 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/DeleteStringFeatureFamilyTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
/**
* Created by christhetree on 1/29/16.
*/
public class DeleteStringFeatureFamilyTransformTest {
private static final Logger log = LoggerFactory.getLogger(
DeleteStringFeatureFamilyTransformTest.class);
public String makeConfig() {
return "test_delete_string_feature_family {\n" +
" transform: delete_string_feature_family\n" +
" fields: [strFeature1, strFeature2, strFeature3]\n" +
"}";
}
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Set<String> list1 = new HashSet<>();
list1.add("I am a string in string feature 1");
stringFeatures.put("strFeature1", list1);
Set<String> list2 = new HashSet<>();
list2.add("I am a string in string feature 2");
stringFeatures.put("strFeature2", list2);
Set<String> list3 = new HashSet<>();
list3.add("I am a string in string feature 3");
stringFeatures.put("strFeature3", list3);
Set<String> list4 = new HashSet<>();
list4.add("I am a string in string feature 4");
stringFeatures.put("strFeature4", list4);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
return featureVector;
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(
config, "test_delete_string_feature_family");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(
config, "test_delete_string_feature_family");
FeatureVector featureVector = makeFeatureVector();
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertNotNull(stringFeatures);
assertTrue(stringFeatures.containsKey("strFeature1"));
assertTrue(stringFeatures.containsKey("strFeature2"));
assertTrue(stringFeatures.containsKey("strFeature3"));
assertTrue(stringFeatures.containsKey("strFeature4"));
assertEquals(4, stringFeatures.size());
transform.doTransform(featureVector);
assertNotNull(stringFeatures);
assertFalse(stringFeatures.containsKey("strFeature1"));
assertFalse(stringFeatures.containsKey("strFeature2"));
assertFalse(stringFeatures.containsKey("strFeature3"));
assertTrue(stringFeatures.containsKey("strFeature4"));
assertEquals(1, stringFeatures.size());
}
}
| 7,124 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/StumpTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class StumpTransformTest {
private static final Logger log = LoggerFactory.getLogger(StumpTransformTest.class);
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("bbb");
stringFeatures.put("strFeature1", list);
Map<String, Double> map = new HashMap<>();
map.put("lat", 37.7);
map.put("long", 40.0);
floatFeatures.put("loc", map);
Map<String, Double> map2 = new HashMap<>();
map2.put("foo", 1.0);
floatFeatures.put("F", map2);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public String makeConfig() {
return "test_stump {\n" +
" transform : stump\n" +
" stumps : [\n" +
" \"loc,lat,30.0,lat>=30.0\"\n"+
" \"loc,lng,50.0,lng>=50.0\"\n"+
" \"fake,fake,50.0,fake>50.0\"\n"+
" \"F,foo,0.0,foo>=0.0\"\n"+
" ]\n" +
" output : bar\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_stump");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_stump");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 2);
Set<String> out = featureVector.stringFeatures.get("bar");
for (String entry : out) {
log.info(entry);
}
assertTrue(out.contains("lat>=30.0"));
assertTrue(out.contains("foo>=0.0"));
}
} | 7,125 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/FloatCrossFloatTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
/**
* Created by christhetree on 4/8/16.
*/
public class FloatCrossFloatTransformTest {
private static final Logger log = LoggerFactory.getLogger(FloatCrossFloatTransformTest.class);
public String makeConfig() {
return "test_float_cross_float {\n" +
" transform : float_cross_float\n" +
" field1 : floatFeature1\n" +
" bucket : 1.0\n" +
" cap : 1000.0\n" +
" field2 : floatFeature2\n" +
" output : out\n" +
"}";
}
public FeatureVector makeFeatureVector() {
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Map<String, Double> floatFeature1 = new HashMap<>();
floatFeature1.put("x", 50.0);
floatFeature1.put("y", 1.3);
floatFeature1.put("z", 2000.0);
Map<String, Double> floatFeature2 = new HashMap<>();
floatFeature2.put("i", 1.2);
floatFeature2.put("j", 3.4);
floatFeature2.put("k", 5.6);
floatFeatures.put("floatFeature1", floatFeature1);
floatFeatures.put("floatFeature2", floatFeature2);
FeatureVector featureVector = new FeatureVector();
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_float_cross_float");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getFloatFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_float_cross_float");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
assertNotNull(floatFeatures);
assertEquals(3, floatFeatures.size());
Map<String, Double> out = floatFeatures.get("out");
assertEquals(9, out.size());
assertEquals(1.2, out.get("x=50.0^i"), 0.0);
assertEquals(1.2, out.get("y=1.0^i"), 0.0);
assertEquals(1.2, out.get("z=1000.0^i"), 0.0);
assertEquals(3.4, out.get("x=50.0^j"), 0.0);
assertEquals(3.4, out.get("y=1.0^j"), 0.0);
assertEquals(3.4, out.get("z=1000.0^j"), 0.0);
assertEquals(5.6, out.get("x=50.0^k"), 0.0);
assertEquals(5.6, out.get("y=1.0^k"), 0.0);
assertEquals(5.6, out.get("z=1000.0^k"), 0.0);
}
}
| 7,126 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/NormalizeFloatTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class NormalizeFloatTransformTest {
private static final Logger log = LoggerFactory.getLogger(CapFloatTransformTest.class);
public String makeConfig() {
return "test_norm {\n" +
" transform : normalize_float\n" +
" field1 : loc\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_norm");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_norm");
FeatureVector featureVector = TransformTestingHelper.makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 1);
Map<String, Double> feat1 = featureVector.getFloatFeatures().get("loc");
assertEquals(3, feat1.size());
double scale = 1.0 / Math.sqrt(37.7 * 37.7 + 40.0 * 40.0 + 20.0 * 20.0);
assertEquals(scale * 37.7, feat1.get("lat"), 0.1);
assertEquals(scale * 40.0, feat1.get("long"), 0.1);
assertEquals(scale * -20.0, feat1.get("z"), 0.1);
}
} | 7,127 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/StringCrossFloatTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class StringCrossFloatTransformTest {
private static final Logger log = LoggerFactory.getLogger(StringCrossFloatTransformTest.class);
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("b:bb");
list.add("c:cc");
stringFeatures.put("strFeature1", list);
Map<String, Double> map = new HashMap<>();
map.put("lat", 37.7);
map.put("long", 40.0);
floatFeatures.put("loc", map);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public String makeConfig() {
return "test_cross {\n" +
" transform : string_cross_float\n" +
" field1 : strFeature1\n" +
" field2 : loc\n" +
" output : out\n" +
"}";
}
public String makeKeysConfig() {
return "test_cross {\n" +
" transform : string_cross_float\n" +
" field1 : strFeature1\n" +
" keys1 : [\"RAW\", \"b\"]\n" +
" field2 : loc\n" +
" keys2 : [\"lat\"]\n" +
" output : out\n" +
"}";
}
@Test
public void testTransformKeys() {
Config config = ConfigFactory.parseString(makeKeysConfig());
Transform transform = TransformFactory.createTransform(config, "test_cross");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertEquals(1, stringFeatures.size());
Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
assertEquals(2, floatFeatures.size());
Map<String, Double> out = floatFeatures.get("out");
assertTrue(out.size() == 2);
log.info("Cross output");
for (Map.Entry<String, Double> entry : out.entrySet()) {
log.info(entry.getKey() + '=' + entry.getValue());
}
assertEquals(37.7, out.get("aaa^lat"), 0.1);
assertEquals(37.7, out.get("b:bb^lat"), 0.1);
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_cross");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_cross");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertEquals(1, stringFeatures.size());
Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
assertEquals(2, floatFeatures.size());
Map<String, Double> out = floatFeatures.get("out");
assertTrue(out.size() == 6);
log.info("Cross output");
for (Map.Entry<String, Double> entry : out.entrySet()) {
log.info(entry.getKey() + '=' + entry.getValue());
}
assertEquals(37.7, out.get("aaa^lat"), 0.1);
assertEquals(37.7, out.get("b:bb^lat"), 0.1);
assertEquals(37.7, out.get("c:cc^lat"), 0.1);
assertEquals(40.0, out.get("aaa^long"), 0.1);
assertEquals(40.0, out.get("b:bb^long"), 0.1);
assertEquals(40.0, out.get("c:cc^long"), 0.1);
}
}
| 7,128 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/SubtractTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class SubtractTransformTest {
private static final Logger log = LoggerFactory.getLogger(SubtractTransformTest.class);
public String makeConfigWithKeys() {
return "test_subtract {\n" +
" transform : subtract\n" +
" field1 : loc\n" +
" field2 : F\n" +
" keys : [\"lat\"] \n" +
" key2 : foo\n" +
" output : bar\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfigWithKeys());
Transform transform = TransformFactory.createTransform(config, "test_subtract");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransformWithKeys() {
Config config = ConfigFactory.parseString(makeConfigWithKeys());
Transform transform = TransformFactory.createTransform(config, "test_subtract");
FeatureVector featureVector = TransformTestingHelper.makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 1);
Map<String, Double> out = featureVector.floatFeatures.get("bar");
for (Map.Entry<String, Double> entry : out.entrySet()) {
log.info(entry.getKey() + "=" + entry.getValue());
}
assertTrue(out.size() == 2);
assertEquals(36.2, out.get("lat-foo"), 0.1);
assertEquals(1.0, out.get("bar_fv"), 0.1);
}
} | 7,129 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/DateValTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
/**
* Created by seckcoder on 12/20/15.
*/
public class DateValTransformTest {
public String makeConfig(String dateType) {
return "test_date {\n" +
" transform: date_val\n" +
" field1: dates\n" +
" date_type: " + dateType + "\n" +
" output: bar\n" +
"}";
}
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set dates = new HashSet<String>();
dates.add("2009-03-01");
dates.add("2009-02-27");
stringFeatures.put("dates", dates);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
@Test
public void testDayOfMonthTransform() {
Config config = ConfigFactory.parseString(makeConfig("day_of_month"));
Transform transform = TransformFactory.createTransform(config, "test_date");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
assertTrue(floatFeatures.size() == 1);
Map<String, Double> out = floatFeatures.get("bar");
assertEquals(out.get("2009-03-01"), 1, 0.1);
assertEquals(out.get("2009-02-27"), 27, 0.1);
}
@Test
public void testDayOfWeekTransform() {
Config config = ConfigFactory.parseString(makeConfig("day_of_week"));
Transform transform = TransformFactory.createTransform(config, "test_date");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
assertTrue(floatFeatures.size() == 1);
Map<String, Double> out = floatFeatures.get("bar");
assertEquals(out.get("2009-03-01"), 1, 0.1);
assertEquals(out.get("2009-02-27"), 6, 0.1);
}
@Test
public void testDayOfYearTransform() {
Config config = ConfigFactory.parseString(makeConfig("day_of_year"));
Transform transform = TransformFactory.createTransform(config, "test_date");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
assertTrue(floatFeatures.size() == 1);
Map<String, Double> out = floatFeatures.get("bar");
assertEquals(out.get("2009-03-01"), 60, 0.1);
assertEquals(out.get("2009-02-27"), 58, 0.1);
}
@Test
public void testYearOfDateTransform() {
Config config = ConfigFactory.parseString(makeConfig("year"));
Transform transform = TransformFactory.createTransform(config, "test_date");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
assertTrue(floatFeatures.size() == 1);
Map<String, Double> out = floatFeatures.get("bar");
assertEquals(out.get("2009-03-01"), 2009, 0.1);
assertEquals(out.get("2009-02-27"), 2009, 0.1);
}
@Test
public void testMonthOfDateTransform() {
Config config = ConfigFactory.parseString(makeConfig("month"));
Transform transform = TransformFactory.createTransform(config, "test_date");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
assertTrue(floatFeatures.size() == 1);
Map<String, Double> out = floatFeatures.get("bar");
assertEquals(out.get("2009-03-01"), 3, 0.1);
assertEquals(out.get("2009-02-27"), 2, 0.1);
}
}
| 7,130 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/MoveFloatToStringTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class MoveFloatToStringTransformTest {
private static final Logger log = LoggerFactory.getLogger(MoveFloatToStringTransformTest.class);
public String makeConfig(boolean moveAllKeys) {
StringBuilder sb = new StringBuilder();
sb.append("test_move_float_to_string {\n");
sb.append(" transform : move_float_to_string\n");
sb.append(" field1 : loc\n");
sb.append(" bucket : 1\n");
if (!moveAllKeys) {
sb.append(" keys : [lat]\n");
}
sb.append(" output : loc_quantized\n");
sb.append("}");
return sb.toString();
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig(false));
Transform transform = TransformFactory.createTransform(config, "test_move_float_to_string");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig(false));
Transform transform = TransformFactory.createTransform(config, "test_move_float_to_string");
FeatureVector featureVector = TransformTestingHelper.makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 2);
Set<String> out = stringFeatures.get("loc_quantized");
assertTrue(out.size() == 1);
log.info("quantize output");
for (String string : out) {
log.info(string);
}
assertTrue(out.contains("lat=37.0"));
}
@Test
public void testTransformMoveAllKeys() {
Config config = ConfigFactory.parseString(makeConfig(true));
Transform transform = TransformFactory.createTransform(config, "test_move_float_to_string");
FeatureVector featureVector = TransformTestingHelper.makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 2);
Set<String> out = stringFeatures.get("loc_quantized");
assertTrue(out.size() == 3);
log.info("quantize output");
for (String string : out) {
log.info(string);
}
assertTrue(out.contains("lat=37.0"));
assertTrue(out.contains("long=40.0"));
assertTrue(out.contains("z=-20.0"));
}
} | 7,131 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/BucketFloatTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.assertEquals;
/**
* @author Hector Yee
*/
public class BucketFloatTransformTest {
private static final Logger log = LoggerFactory.getLogger(BucketFloatTransformTest.class);
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("bbb");
stringFeatures.put("strFeature1", list);
Map<String, Double> map = new HashMap<>();
map.put("lat", 37.7);
map.put("long", 40.4);
map.put("zero", 0.0);
map.put("negative", -1.5);
floatFeatures.put("loc", map);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public String makeConfig() {
return "test_quantize {\n" +
" transform : bucket_float\n" +
" field1 : loc\n" +
" bucket : 1.0\n" +
" output : loc_quantized\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_quantize");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_quantize");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 1);
Map<String, Double> out = featureVector.getFloatFeatures().get("loc_quantized");
log.info("quantize output");
for (Map.Entry<String, Double> entry : out.entrySet()) {
log.info(entry.getKey() + "=" + entry.getValue());
}
assertTrue(out.size() == 4);
assertEquals(0.7, out.get("lat[1.0]=37.0").doubleValue(), 0.1);
assertEquals(0.4, out.get("long[1.0]=40.0").doubleValue(), 0.1);
assertEquals(0.0, out.get("zero[1.0]=0.0").doubleValue(), 0.1);
assertEquals(-0.5, out.get("negative[1.0]=-1.0").doubleValue(), 0.1);
}
} | 7,132 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/MultiscaleGridQuantizeTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class MultiscaleGridQuantizeTransformTest {
private static final Logger log = LoggerFactory.getLogger(MultiscaleGridQuantizeTransformTest.class);
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("bbb");
stringFeatures.put("strFeature1", list);
Map<String, Double> map = new HashMap<>();
map.put("lat", 37.7);
map.put("long", 40.0);
floatFeatures.put("loc", map);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public String makeConfig() {
return "test_quantize {\n" +
" transform : multiscale_grid_quantize\n" +
" field1 : loc\n" +
" value1 : lat\n" +
" value2 : long\n" +
" buckets : [1, 10]\n" +
" output : loc_quantized\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_quantize");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_quantize");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 2);
Set<String> out = stringFeatures.get("loc_quantized");
log.info("quantize output");
for (String string : out) {
log.info(string);
}
assertTrue(out.size() == 2);
assertTrue(out.contains("[10.0]=(30.0,40.0)"));
assertTrue(out.contains("[1.0]=(37.0,40.0)"));
}
} | 7,133 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/ModelTransformsTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.Example;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import static org.junit.Assert.assertTrue;
// Tests all the model transforms.
public class ModelTransformsTest {
private static final Logger log = LoggerFactory.getLogger(ModelTransformsTest.class);
// Creates a feature vector given a feature family name and latitude and longitude features.
public FeatureVector makeFeatureVector(String familyName,
Double lat,
Double lng) {
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Map<String, List<Double>> denseFeatures = new HashMap<>();
Map<String, Double> map = new HashMap<>();
map.put("lat", lat);
map.put("long", lng);
floatFeatures.put(familyName, map);
List<Double> list = new ArrayList<>();
list.add(lat);
list.add(lng);
String denseFamilyName = familyName + "_dense";
denseFeatures.put(denseFamilyName, list);
FeatureVector featureVector = new FeatureVector();
featureVector.setFloatFeatures(floatFeatures);
featureVector.setDenseFeatures(denseFeatures);
return featureVector;
}
public String makeConfig() {
return "quantize_guest_loc {\n" +
" transform : quantize\n" +
" field1 : guest_loc\n" +
" scale : 10\n" +
" output : guest_loc_quantized\n" +
"}\n" +
"quantize_host_loc {\n" +
" transform : quantize\n" +
" field1 : host_loc\n" +
" scale : 10\n" +
" output : host_loc_quantized\n" +
"}\n" +
"cross_guest_host_loc {\n" +
" transform : cross\n" +
" field1 : guest_loc_quantized\n" +
" field2 : host_loc_quantized\n" +
" output : gxh_loc\n" +
"}\n" +
"context_transform {\n" +
" transform : list\n" +
" transforms : [quantize_guest_loc]\n" +
"}\n" +
"item_transform {\n" +
" transform : list\n" +
" transforms : [quantize_host_loc]\n" +
"}\n" +
"combined_transform {\n" +
" transform : list\n" +
" transforms : [cross_guest_host_loc]\n" +
"}\n" +
"model_transforms {\n" +
" context_transform : context_transform\n" +
" item_transform : item_transform\n" +
" combined_transform : combined_transform\n" +
"}";
}
private Example makeExample() {
Example example = new Example();
example.setContext(makeFeatureVector("guest_loc", 1.0, 2.0));
example.addToExample(makeFeatureVector("host_loc", 3.1, 4.2));
example.addToExample(makeFeatureVector("host_loc", 5.3, 6.4));
return example;
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transformer transformer = new Transformer(config, "model_transforms");
Example example = makeExample();
transformer.combineContextAndItems(example);
assertTrue(example.example.size() == 2);
FeatureVector ex = example.example.get(0);
assertTrue(ex.stringFeatures.size() == 3);
assertTrue(ex.stringFeatures.get("guest_loc_quantized").contains("lat=10"));
assertTrue(ex.stringFeatures.get("guest_loc_quantized").contains("long=20"));
assertTrue(ex.stringFeatures.get("host_loc_quantized").contains("lat=31"));
assertTrue(ex.stringFeatures.get("host_loc_quantized").contains("long=42"));
assertTrue(ex.stringFeatures.get("gxh_loc").contains("lat=10^lat=31"));
assertTrue(ex.stringFeatures.get("gxh_loc").contains("long=20^lat=31"));
assertTrue(ex.stringFeatures.get("gxh_loc").contains("lat=10^long=42"));
assertTrue(ex.stringFeatures.get("gxh_loc").contains("long=20^long=42"));
assertTrue(ex.floatFeatures.get("guest_loc").get("lat") == 1.0);
assertTrue(ex.floatFeatures.get("guest_loc").get("long") == 2.0);
assertTrue(ex.floatFeatures.get("host_loc").get("lat") == 3.1);
assertTrue(ex.floatFeatures.get("host_loc").get("long") == 4.2);
assertTrue(ex.denseFeatures.get("guest_loc_dense").contains(1.0));
assertTrue(ex.denseFeatures.get("guest_loc_dense").contains(2.0));
assertTrue(ex.denseFeatures.get("host_loc_dense").contains(3.1));
assertTrue(ex.denseFeatures.get("host_loc_dense").contains(4.2));
log.info(example.toString());
}
} | 7,134 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/KdtreeContinuousTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class KdtreeContinuousTransformTest {
private static final Logger log = LoggerFactory.getLogger(KdtreeContinuousTransformTest.class);
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("bbb");
stringFeatures.put("strFeature1", list);
Map<String, Double> map = new HashMap<>();
map.put("lat", 37.7);
map.put("long", 40.0);
floatFeatures.put("loc", map);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public String makeConfig() {
return "test_kdtree {\n" +
" transform : kdtree_continuous\n" +
" include \"test_kdt.model.conf\"\n" +
" field1 : loc\n" +
" value1 : lat\n" +
" value2 : long\n" +
" max_count : 3\n" +
" output : loc_kdt\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_kdtree");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
log.info("Model encoded is " + config.getString("test_kdtree.model_base64"));
Transform transform = TransformFactory.createTransform(config, "test_kdtree");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 1);
Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
Map<String, Double> out = floatFeatures.get("loc_kdt");
log.info("loc_kdt");
for (Map.Entry<String, Double> entry : out.entrySet()) {
log.info(entry.getKey() + " = " + entry.getValue());
}
assertTrue(out.size() == 2);
// 4
// |--------------- y = 2
// 1 | 2 3
// x = 1
assertEquals(out.get("0"), 37.7 - 1.0, 0.1);
assertEquals(out.get("2"), 40.0 - 2.0, 0.1);
}
} | 7,135 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/NgramTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* Created by christhetree on 4/22/16.
*/
public class NgramTransformTest {
private static final Logger log = LoggerFactory.getLogger(NgramTransformTest.class);
public String makeConfig(String regex, int n, boolean useMinN) {
StringBuilder sb = new StringBuilder();
sb.append("test_ngram {\n");
sb.append(" transform: ngram\n");
sb.append(" field1: strFeature1\n");
sb.append(" regex: ");
sb.append(regex);
sb.append("\n");
sb.append(" n: ");
sb.append(n);
sb.append("\n");
if (useMinN) {
sb.append(" min_n: 1\n");
}
sb.append(" output: bar\n");
sb.append("}");
return sb.toString();
}
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set<String> list = new HashSet<>();
list.add("I like blueberry pie, apple pie; and I also like blue!");
list.add("I'm so excited: I like blue!?!!");
stringFeatures.put("strFeature1", list);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig("regex", 2, false));
Transform transform = TransformFactory.createTransform(config, "test_ngram");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
assertTrue(featureVector.getFloatFeatures() == null);
}
@Test
public void testTransform1gram() {
Config config = ConfigFactory.parseString(makeConfig("\"\"\"[\\s\\p{Punct}]\"\"\"", 1, false));
Transform transform = TransformFactory.createTransform(config, "test_ngram");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
assertEquals(1, stringFeatures.size());
assertEquals(1, floatFeatures.size());
Map<String, Double> output = floatFeatures.get("bar");
assertEquals(11, output.size());
assertEquals(1.0, output.get("apple"), 0.0);
assertEquals(1.0, output.get("blueberry"), 0.0);
assertEquals(2.0, output.get("blue"), 0.0);
assertEquals(3.0, output.get("like"), 0.0);
assertEquals(1.0, output.get("excited"), 0.0);
assertEquals(1.0, output.get("and"), 0.0);
assertEquals(4.0, output.get("I"), 0.0);
assertEquals(1.0, output.get("also"), 0.0);
assertEquals(1.0, output.get("so"), 0.0);
assertEquals(2.0, output.get("pie"), 0.0);
assertEquals(1.0, output.get("m"), 0.0);
}
@Test
public void testTransform2gram() {
Config config = ConfigFactory.parseString(makeConfig("\"\"\"[\\s\\p{Punct}]\"\"\"", 2, false));
Transform transform = TransformFactory.createTransform(config, "test_ngram");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
assertEquals(1, stringFeatures.size());
assertEquals(1, floatFeatures.size());
Map<String, Double> output = floatFeatures.get("bar");
assertEquals(14, output.size());
assertEquals(2.0, output.get("I" + NgramTransform.BIGRAM_SEPARATOR + "like"), 0.0);
assertEquals(1.0, output.get("like" + NgramTransform.BIGRAM_SEPARATOR + "blueberry"), 0.0);
assertEquals(1.0, output.get("blueberry" + NgramTransform.BIGRAM_SEPARATOR + "pie"), 0.0);
assertEquals(1.0, output.get("pie" + NgramTransform.BIGRAM_SEPARATOR + "apple"), 0.0);
assertEquals(1.0, output.get("apple" + NgramTransform.BIGRAM_SEPARATOR + "pie"), 0.0);
assertEquals(1.0, output.get("pie" + NgramTransform.BIGRAM_SEPARATOR + "and"), 0.0);
assertEquals(1.0, output.get("and" + NgramTransform.BIGRAM_SEPARATOR + "I"), 0.0);
assertEquals(1.0, output.get("I" + NgramTransform.BIGRAM_SEPARATOR + "also"), 0.0);
assertEquals(1.0, output.get("also" + NgramTransform.BIGRAM_SEPARATOR + "like"), 0.0);
assertEquals(2.0, output.get("like" + NgramTransform.BIGRAM_SEPARATOR + "blue"), 0.0);
assertEquals(1.0, output.get("I" + NgramTransform.BIGRAM_SEPARATOR + "m"), 0.0);
assertEquals(1.0, output.get("m" + NgramTransform.BIGRAM_SEPARATOR + "so"), 0.0);
assertEquals(1.0, output.get("so" + NgramTransform.BIGRAM_SEPARATOR + "excited"), 0.0);
assertEquals(1.0, output.get("excited" + NgramTransform.BIGRAM_SEPARATOR + "I"), 0.0);
}
@Test
public void testTransform11gram() {
Config config = ConfigFactory.parseString(makeConfig("\"\"\"[\\s\\p{Punct}]\"\"\"", 11, false));
Transform transform = TransformFactory.createTransform(config, "test_ngram");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
assertEquals(1, stringFeatures.size());
assertEquals(1, floatFeatures.size());
Map<String, Double> output = floatFeatures.get("bar");
assertEquals(1, output.size());
}
@Test
public void testTransform99gram() {
Config config = ConfigFactory.parseString(makeConfig("\"\"\"[\\s\\p{Punct}]\"\"\"", 99, false));
Transform transform = TransformFactory.createTransform(config, "test_ngram");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
assertEquals(1, stringFeatures.size());
assertEquals(1, floatFeatures.size());
Map<String, Double> output = floatFeatures.get("bar");
assertEquals(0, output.size());
}
@Test
public void testTransformUseMinN() {
Config config = ConfigFactory.parseString(makeConfig("\"\"\"[\\s\\p{Punct}]\"\"\"", 2, true));
Transform transform = TransformFactory.createTransform(config, "test_ngram");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
assertEquals(1, stringFeatures.size());
assertEquals(1, floatFeatures.size());
Map<String, Double> output = floatFeatures.get("bar");
assertEquals(25, output.size());
assertEquals(1.0, output.get("apple"), 0.0);
assertEquals(1.0, output.get("blueberry"), 0.0);
assertEquals(2.0, output.get("blue"), 0.0);
assertEquals(3.0, output.get("like"), 0.0);
assertEquals(1.0, output.get("excited"), 0.0);
assertEquals(1.0, output.get("and"), 0.0);
assertEquals(4.0, output.get("I"), 0.0);
assertEquals(1.0, output.get("also"), 0.0);
assertEquals(1.0, output.get("so"), 0.0);
assertEquals(2.0, output.get("pie"), 0.0);
assertEquals(1.0, output.get("m"), 0.0);
assertEquals(2.0, output.get("I" + NgramTransform.BIGRAM_SEPARATOR + "like"), 0.0);
assertEquals(1.0, output.get("like" + NgramTransform.BIGRAM_SEPARATOR + "blueberry"), 0.0);
assertEquals(1.0, output.get("blueberry" + NgramTransform.BIGRAM_SEPARATOR + "pie"), 0.0);
assertEquals(1.0, output.get("pie" + NgramTransform.BIGRAM_SEPARATOR + "apple"), 0.0);
assertEquals(1.0, output.get("apple" + NgramTransform.BIGRAM_SEPARATOR + "pie"), 0.0);
assertEquals(1.0, output.get("pie" + NgramTransform.BIGRAM_SEPARATOR + "and"), 0.0);
assertEquals(1.0, output.get("and" + NgramTransform.BIGRAM_SEPARATOR + "I"), 0.0);
assertEquals(1.0, output.get("I" + NgramTransform.BIGRAM_SEPARATOR + "also"), 0.0);
assertEquals(1.0, output.get("also" + NgramTransform.BIGRAM_SEPARATOR + "like"), 0.0);
assertEquals(2.0, output.get("like" + NgramTransform.BIGRAM_SEPARATOR + "blue"), 0.0);
assertEquals(1.0, output.get("I" + NgramTransform.BIGRAM_SEPARATOR + "m"), 0.0);
assertEquals(1.0, output.get("m" + NgramTransform.BIGRAM_SEPARATOR + "so"), 0.0);
assertEquals(1.0, output.get("so" + NgramTransform.BIGRAM_SEPARATOR + "excited"), 0.0);
assertEquals(1.0, output.get("excited" + NgramTransform.BIGRAM_SEPARATOR + "I"), 0.0);
}
}
| 7,136 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/DefaultStringTokenizerTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* Created by christhetree on 1/27/16.
*/
public class DefaultStringTokenizerTransformTest {
private static final Logger log = LoggerFactory.getLogger(
DefaultStringTokenizerTransformTest.class);
public String makeConfig(String regex, boolean generateBigrams) {
return "test_tokenizer {\n" +
" transform: default_string_tokenizer\n" +
" field1: strFeature1\n" +
" regex: " + regex + "\n" +
" output: bar\n" +
" generate_bigrams: " + Boolean.toString(generateBigrams) + "\n" +
" bigrams_output: bigrams\n" +
"}";
}
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set list = new HashSet<String>();
list.add("I like blueberry pie, apple pie; and I also like blue!");
list.add("I'm so excited: I like blue!?!!");
stringFeatures.put("strFeature1", list);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig("regex", false));
Transform transform = TransformFactory.createTransform(config, "test_tokenizer");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
assertTrue(featureVector.getFloatFeatures() == null);
}
@Test
public void testTransformWithoutBigrams() {
Config config = ConfigFactory.parseString(makeConfig("\"\"\"[\\s\\p{Punct}]\"\"\"", false));
Transform transform = TransformFactory.createTransform(config, "test_tokenizer");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
assertEquals(1, stringFeatures.size());
assertEquals(1, floatFeatures.size());
Map<String, Double> output = floatFeatures.get("bar");
assertEquals(11, output.size());
assertEquals(1.0, output.get("apple"), 0.0);
assertEquals(1.0, output.get("blueberry"), 0.0);
assertEquals(2.0, output.get("blue"), 0.0);
assertEquals(3.0, output.get("like"), 0.0);
assertEquals(1.0, output.get("excited"), 0.0);
assertEquals(1.0, output.get("and"), 0.0);
assertEquals(4.0, output.get("I"), 0.0);
assertEquals(1.0, output.get("also"), 0.0);
assertEquals(1.0, output.get("so"), 0.0);
assertEquals(2.0, output.get("pie"), 0.0);
assertEquals(1.0, output.get("m"), 0.0);
}
@Test
public void testTransformWithBigrams() {
Config config = ConfigFactory.parseString(makeConfig("\"\"\"[\\s\\p{Punct}]\"\"\"", true));
Transform transform = TransformFactory.createTransform(config, "test_tokenizer");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
assertEquals(1, stringFeatures.size());
assertEquals(2, floatFeatures.size());
Map<String, Double> output = floatFeatures.get("bar");
assertEquals(11, output.size());
assertEquals(1.0, output.get("apple"), 0.0);
assertEquals(1.0, output.get("blueberry"), 0.0);
assertEquals(2.0, output.get("blue"), 0.0);
assertEquals(3.0, output.get("like"), 0.0);
assertEquals(1.0, output.get("excited"), 0.0);
assertEquals(1.0, output.get("and"), 0.0);
assertEquals(4.0, output.get("I"), 0.0);
assertEquals(1.0, output.get("also"), 0.0);
assertEquals(1.0, output.get("so"), 0.0);
assertEquals(2.0, output.get("pie"), 0.0);
assertEquals(1.0, output.get("m"), 0.0);
Map<String, Double> bigrams = floatFeatures.get("bigrams");
assertEquals(14, bigrams.size());
assertEquals(2.0, bigrams.get("I" + NgramTransform.BIGRAM_SEPARATOR + "like"), 0.0);
assertEquals(1.0, bigrams.get("like" + NgramTransform.BIGRAM_SEPARATOR + "blueberry"), 0.0);
assertEquals(1.0, bigrams.get("blueberry" + NgramTransform.BIGRAM_SEPARATOR + "pie"), 0.0);
assertEquals(1.0, bigrams.get("pie" + NgramTransform.BIGRAM_SEPARATOR + "apple"), 0.0);
assertEquals(1.0, bigrams.get("apple" + NgramTransform.BIGRAM_SEPARATOR + "pie"), 0.0);
assertEquals(1.0, bigrams.get("pie" + NgramTransform.BIGRAM_SEPARATOR + "and"), 0.0);
assertEquals(1.0, bigrams.get("and" + NgramTransform.BIGRAM_SEPARATOR + "I"), 0.0);
assertEquals(1.0, bigrams.get("I" + NgramTransform.BIGRAM_SEPARATOR + "also"), 0.0);
assertEquals(1.0, bigrams.get("also" + NgramTransform.BIGRAM_SEPARATOR + "like"), 0.0);
assertEquals(2.0, bigrams.get("like" + NgramTransform.BIGRAM_SEPARATOR + "blue"), 0.0);
assertEquals(1.0, bigrams.get("I" + NgramTransform.BIGRAM_SEPARATOR + "m"), 0.0);
assertEquals(1.0, bigrams.get("m" + NgramTransform.BIGRAM_SEPARATOR + "so"), 0.0);
assertEquals(1.0, bigrams.get("so" + NgramTransform.BIGRAM_SEPARATOR + "excited"), 0.0);
assertEquals(1.0, bigrams.get("excited" + NgramTransform.BIGRAM_SEPARATOR + "I"), 0.0);
}
}
| 7,137 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/NearestTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class NearestTransformTest {
private static final Logger log = LoggerFactory.getLogger(NearestTransformTest.class);
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("bbb");
stringFeatures.put("strFeature1", list);
Map<String, Double> map = new HashMap<>();
map.put("lat", 37.7);
map.put("long", 40.0);
floatFeatures.put("loc", map);
Map<String, Double> map2 = new HashMap<>();
map2.put("foo", 41.0);
floatFeatures.put("f2", map2);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public String makeConfig() {
return "test_nearest {\n" +
" transform : nearest\n" +
" field1 : loc\n" +
" field2 : f2\n" +
" key: foo\n" +
" output : nearest\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_nearest");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_nearest");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 2);
Set<String> out = stringFeatures.get("nearest");
log.info("nearest output");
for (String string : out) {
log.info(string);
}
assertTrue(out.size() == 1);
assertTrue(out.contains("foo~=long"));
}
} | 7,138 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/FloatToStringTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
public class FloatToStringTransformTest {
public String makeConfig() {
return "test_float_to_string_and_float {\n" +
" transform : float_to_string\n" +
" field1 : floatFeature1\n" +
" keys : [a, b, g]\n" +
" values : [0.0, 10.0]\n" +
" string_output : stringOutput\n" +
"}";
}
public FeatureVector makeFeatureVector() {
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Map<String, Double> floatFeature1 = new HashMap<>();
floatFeature1.put("a", 0.0);
floatFeature1.put("b", 10.0);
floatFeature1.put("c", 21.3);
floatFeature1.put("d", 10.1);
floatFeature1.put("e", 11.01);
floatFeature1.put("f", -1.01);
floatFeature1.put("g", 0d);
floatFeatures.put("floatFeature1", floatFeature1);
FeatureVector featureVector = new FeatureVector();
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(
config, "test_float_to_string_and_float");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
assertTrue(featureVector.getFloatFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(
config, "test_float_to_string_and_float");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
assertNotNull(stringFeatures);
assertEquals(1, stringFeatures.size());
assertNotNull(floatFeatures);
assertEquals(1, floatFeatures.size());
Set<String> stringOutput = stringFeatures.get("stringOutput");
Map<String, Double> floatOutput = floatFeatures.get("floatFeature1");
assertEquals(3, stringOutput.size());
assertEquals(4, floatOutput.size());
assertTrue(stringOutput.contains("a=0.0"));
assertTrue(stringOutput.contains("b=10.0"));
assertTrue(stringOutput.contains("g=0.0"));
assertEquals(21.3, floatOutput.get("c"), 0.0);
assertEquals(10.1, floatOutput.get("d"), 0.0);
assertEquals(11.01, floatOutput.get("e"), 0.0);
assertEquals(-1.01, floatOutput.get("f"), 0.0);
}
}
| 7,139 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/MoveFloatToStringAndFloatTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
/**
* Created by christhetree on 4/8/16.
*/
public class MoveFloatToStringAndFloatTransformTest {
private static final Logger log = LoggerFactory.getLogger(
MoveFloatToStringAndFloatTransformTest.class);
public String makeConfig() {
return "test_move_float_to_string_and_float {\n" +
" transform : move_float_to_string_and_float\n" +
" field1 : floatFeature1\n" +
" keys : [a, b, c, d, e, f, g, h, i]\n" +
" bucket : 1.0\n" +
" max_bucket : 10.0\n" +
" min_bucket : 0.0\n" +
" string_output : stringOutput\n" +
" float_output : floatOutput\n" +
"}";
}
public FeatureVector makeFeatureVector() {
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Map<String, Double> floatFeature1 = new HashMap<>();
floatFeature1.put("a", 0.0);
floatFeature1.put("b", 10.0);
floatFeature1.put("c", 9.9);
floatFeature1.put("d", 10.1);
floatFeature1.put("e", 11.01);
floatFeature1.put("f", -0.1);
floatFeature1.put("g", -1.01);
floatFeature1.put("h", 21.3);
floatFeature1.put("i", 2000.0);
floatFeature1.put("j", 1.0);
floatFeature1.put("k", 9000.0);
floatFeatures.put("floatFeature1", floatFeature1);
FeatureVector featureVector = new FeatureVector();
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(
config, "test_move_float_to_string_and_float");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
assertTrue(featureVector.getFloatFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(
config, "test_move_float_to_string_and_float");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
assertNotNull(stringFeatures);
assertEquals(1, stringFeatures.size());
assertNotNull(floatFeatures);
assertEquals(2, floatFeatures.size());
Set<String> stringOutput = stringFeatures.get("stringOutput");
Map<String, Double> floatOutput = floatFeatures.get("floatOutput");
assertEquals(5, stringOutput.size());
assertEquals(4, floatOutput.size());
assertTrue(stringOutput.contains("a=0.0"));
assertTrue(stringOutput.contains("b=10.0"));
assertTrue(stringOutput.contains("c=9.0"));
assertTrue(stringOutput.contains("d=10.0"));
assertTrue(stringOutput.contains("f=0.0"));
assertEquals(11.01, floatOutput.get("e"), 0.0);
assertEquals(-1.01, floatOutput.get("g"), 0.0);
assertEquals(21.3, floatOutput.get("h"), 0.0);
assertEquals(2000.0, floatOutput.get("i"), 0.0);
}
}
| 7,140 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/ListTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.HashSet;
import java.util.Map;
import java.util.List;
import java.util.HashMap;
import java.util.Set;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class ListTransformTest {
private static final Logger log = LoggerFactory.getLogger(ListTransformTest.class);
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("bbb");
stringFeatures.put("strFeature1", list);
Map<String, Double> map = new HashMap<>();
map.put("lat", 37.7);
map.put("long", 40.0);
floatFeatures.put("loc", map);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public String makeConfig() {
return "test_quantize {\n" +
" transform : quantize\n" +
" field1 : loc\n" +
" scale : 10\n" +
" output : loc_quantized\n" +
"}\n" +
"test_cross {\n" +
" transform : cross\n" +
" field1 : strFeature1\n" +
" field2 : loc_quantized\n" +
" output : out\n" +
"}\n" +
"test_list {\n" +
" transform : list\n" +
" transforms : [test_quantize, test_cross]\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_list");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_list");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 3);
Set<String> out = stringFeatures.get("out");
assertTrue(out.size() == 4);
log.info("crossed quantized output");
for (String string : out) {
log.info(string);
}
assertTrue(out.contains("bbb^long=400"));
assertTrue(out.contains("aaa^lat=377"));
}
} | 7,141 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/KdtreeTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class KdtreeTransformTest {
private static final Logger log = LoggerFactory.getLogger(KdtreeTransformTest.class);
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("bbb");
stringFeatures.put("strFeature1", list);
Map<String, Double> map = new HashMap<>();
map.put("lat", 37.7);
map.put("long", 40.0);
floatFeatures.put("loc", map);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public String makeConfig() {
return "test_kdtree {\n" +
" transform : kdtree\n" +
" include \"test_kdt.model.conf\"\n" +
" field1 : loc\n" +
" value1 : lat\n" +
" value2 : long\n" +
" max_count : 2\n" +
" output : loc_kdt\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_kdtree");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
log.info("Model encoded is " + config.getString("test_kdtree.model_base64"));
Transform transform = TransformFactory.createTransform(config, "test_kdtree");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 2);
Set<String> out = stringFeatures.get("loc_kdt");
log.info("loc_kdt");
for (String string : out) {
log.info(string);
}
assertTrue(out.size() == 2);
assertTrue(out.contains("2"));
assertTrue(out.contains("4"));
}
} | 7,142 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/StuffIdTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class StuffIdTransformTest {
private static final Logger log = LoggerFactory.getLogger(StuffIdTransformTest.class);
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("bbb");
stringFeatures.put("strFeature1", list);
Map<String, Double> map = new HashMap<>();
map.put("searches", 37.7);
floatFeatures.put("FEAT", map);
Map<String, Double> map2 = new HashMap<>();
map2.put("id", 123456789.0);
floatFeatures.put("ID", map2);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public String makeConfig() {
return "test_stuff {\n" +
" transform : stuff_id\n" +
" field1 : ID\n" +
" key1 : id\n" +
" field2 : FEAT\n" +
" key2 : searches\n" +
" output : bar\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_stuff");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_stuff");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 1);
log.info(featureVector.toString());
Map<String, Double> out = featureVector.floatFeatures.get("bar");
for (Map.Entry<String, Double> entry : out.entrySet()) {
log.info(entry.getKey() + "=" + entry.getValue());
}
assertTrue(out.size() == 1);
assertEquals(37.7, out.get("searches@123456789"), 0.1);
}
} | 7,143 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/MathFloatTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import java.util.Map;
import java.util.Set;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
public class MathFloatTransformTest {
private static final Logger log = LoggerFactory.getLogger(MathFloatTransformTest.class);
public String makeConfig(String functionName) {
return "test_math {\n" +
" transform : math_float\n" +
" field1 : loc\n" +
" keys : [lat,long,z]\n" +
" output : bar\n" +
" function : " + functionName +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig("log10"));
Transform transform = TransformFactory.createTransform(config, "test_math");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getFloatFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig("log10"));
Transform transform = TransformFactory.createTransform(config, "test_math");
FeatureVector featureVector = TransformTestingHelper.makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 1);
Map<String, Double> feat1 = featureVector.getFloatFeatures().get("loc");
// the original features are not changed
assertEquals(3, feat1.size());
assertEquals(37.7, feat1.get("lat"), 0.1);
assertEquals(40.0, feat1.get("long"), 0.1);
assertEquals(-20.0, feat1.get("z"), 0.1);
Map<String, Double> feat2 = featureVector.getFloatFeatures().get("bar");
assertEquals(3, feat2.size());
assertEquals(Math.log10(37.7), feat2.get("lat"), 0.1);
assertEquals(Math.log10(40.0), feat2.get("long"), 0.1);
// for negative value, it would be a missing feature
assertTrue(!feat2.containsKey("z"));
// existing feature in 'bar' should not change
assertEquals(1.0, feat2.get("bar_fv"), 0.1);
// test an undefined function
Config config2 = ConfigFactory.parseString(makeConfig("tan"));
Transform transform2 = TransformFactory.createTransform(config2, "test_math");
FeatureVector featureVector2 = TransformTestingHelper.makeFeatureVector();
transform2.doTransform(featureVector2);
// the original features are unchanged
Map<String, Double> feat3 = featureVector2.getFloatFeatures().get("loc");
assertEquals(3, feat3.size());
assertEquals(37.7, feat3.get("lat"), 0.1);
assertEquals(40.0, feat3.get("long"), 0.1);
assertEquals(-20.0, feat3.get("z"), 0.1);
// new features should not exist
Map<String, Double> feat4 = featureVector2.getFloatFeatures().get("bar");
assertEquals(1, feat4.size());
assertEquals(1.0, feat4.get("bar_fv"), 0.1);
}
}
| 7,144 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/DecisionTreeTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.airbnb.aerosolve.core.ModelRecord;
import com.airbnb.aerosolve.core.models.DecisionTreeModel;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class DecisionTreeTransformTest {
private static final Logger log = LoggerFactory.getLogger(DecisionTreeTransformTest.class);
public FeatureVector makeFeatureVector(double x, double y) {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("bbb");
stringFeatures.put("strFeature1", list);
Map<String, Double> map = new HashMap<>();
map.put("x", x);
map.put("y", y);
floatFeatures.put("loc", map);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public String makeConfig() {
return "test_tree {\n" +
" transform : decision_tree\n" +
" output_leaves : \"LEAF\" \n" +
" output_score_family : \"SCORE\" \n" +
" output_score_name : \"TREE0\" \n" +
" nodes : [\n" +
" \"P,0,loc,x,2.000000,1,2\" \n" +
" \"P,1,loc,y,0.000000,3,4\" \n" +
" \"P,2,loc,y,1.000000,5,6\" \n" +
" \"L,3,0.250000,BOTTOM_LEFT\" \n" +
" \"L,4,-0.500000,TOP_LEFT\" \n" +
" \"L,5,-0.750000,BOTTOM_RIGHT\" \n" +
" \"L,6,1.000000,TOP_RIGHT\" \n" +
" ]\n" +
"}";
}
/*
* XOR like decision regions
*
* x = 2
* |
* -0.5 | 1.0
* |-------- y = 1
* -------- y = 0
* |
* 0.25 | -0.75
* |
*/
public DecisionTreeModel makeTree() {
ArrayList<ModelRecord> records = new ArrayList<>();
DecisionTreeModel tree = new DecisionTreeModel();
tree.setStumps(records);
// 0 - an x split at 2
ModelRecord record = new ModelRecord();
record.setFeatureFamily("loc");
record.setFeatureName("x");
record.setThreshold(2.0);
record.setLeftChild(1);
record.setRightChild(2);
records.add(record);
// 1 - a y split at 0
record = new ModelRecord();
record.setFeatureFamily("loc");
record.setFeatureName("y");
record.setThreshold(0.0);
record.setLeftChild(3);
record.setRightChild(4);
records.add(record);
// 2 - a y split at 1
record = new ModelRecord();
record.setFeatureFamily("loc");
record.setFeatureName("y");
record.setThreshold(1.0);
record.setLeftChild(5);
record.setRightChild(6);
records.add(record);
// 3 a leaf
record = new ModelRecord();
record.setFeatureWeight(0.25);
records.add(record);
// 4 a leaf
record = new ModelRecord();
record.setFeatureWeight(-0.5);
records.add(record);
// 5 a leaf
record = new ModelRecord();
record.setFeatureWeight(-0.75);
records.add(record);
// 6 a leaf
record = new ModelRecord();
record.setFeatureWeight(1.0);
records.add(record);
return tree;
}
@Test
public void testToHumanReadableConfig() {
DecisionTreeModel tree = makeTree();
String result = tree.toHumanReadableTransform();
log.info(result);
String tokens[] = result.split("\n");
assertEquals(9, tokens.length);
assertTrue(tokens[3].contains("P,2,loc,y,1.000000,5,6"));
assertTrue(tokens[4].contains("L,3,0.250000,LEAF_3"));
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_tree");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
public void testTransformAt(double x, double y, String expectedLeaf, double expectedOutput) {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_tree");
FeatureVector featureVector;
featureVector = makeFeatureVector(x, y);
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertEquals(2, stringFeatures.size());
Set<String> out = featureVector.stringFeatures.get("LEAF");
for (String entry : out) {
log.info(entry);
}
assertTrue(out.contains(expectedLeaf));
Map<String, Double> treeOutput = featureVector.floatFeatures.get("SCORE");
assertTrue(treeOutput.containsKey("TREE0"));
assertEquals(expectedOutput, treeOutput.get("TREE0"), 0.1);
}
@Test
public void testTransform() {
testTransformAt(10.0, 10.0, "TOP_RIGHT", 1.0);
testTransformAt(10.0, -10.0, "BOTTOM_RIGHT", -0.75);
testTransformAt(-10.0, 10.0, "TOP_LEFT", -0.5);
testTransformAt(-10.0, -10.0, "BOTTOM_LEFT", 0.25);
}
} | 7,145 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/CustomMultiscaleQuantizeTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import java.util.HashSet;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static org.junit.Assert.assertTrue;
public class CustomMultiscaleQuantizeTransformTest {
private static final Logger log = LoggerFactory.getLogger(CustomMultiscaleQuantizeTransformTest.class);
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("bbb");
stringFeatures.put("strFeature1", list);
Map<String, Double> map = new HashMap<>();
map.put("lat", 37.7);
map.put("long", 40.0);
map.put("zero", 0.0);
map.put("negative", -1.0);
floatFeatures.put("loc", map);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public String makeConfig(String input) {
return "test_quantize {\n" +
" transform : custom_multiscale_quantize\n" +
" field1 : loc\n" + input +
" buckets : [1, 10]\n" +
" output : loc_quantized\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig(""));
Transform transform = TransformFactory.createTransform(config, "test_quantize");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig(""));
Transform transform = TransformFactory.createTransform(config, "test_quantize");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 2);
Set<String> out = stringFeatures.get("loc_quantized");
log.info("quantize output");
for (String string : out) {
log.info(string);
}
assertTrue(out.size() == 7);
assertTrue(out.contains("lat[10.0]=30.0"));
assertTrue(out.contains("long[1.0]=40.0"));
assertTrue(out.contains("long[10.0]=40.0"));
assertTrue(out.contains("lat[1.0]=37.0"));
assertTrue(out.contains("zero=0"));
assertTrue(out.contains("negative[1.0]=-1.0"));
assertTrue(out.contains("negative[10.0]=0.0"));
}
@Test
public void testSelectFeatures() {
Config config = ConfigFactory.parseString(makeConfig("select_features: [\"lat\"] \n"));
Transform transform = TransformFactory.createTransform(config, "test_quantize");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 2);
Set<String> out = stringFeatures.get("loc_quantized");
log.info("quantize output");
for (String string : out) {
log.info(string);
}
assertTrue(out.size() == 2);
assertTrue(out.contains("lat[10.0]=30.0"));
assertTrue(out.contains("lat[1.0]=37.0"));
}
@Test
public void testExcludeFeatures() {
Config config = ConfigFactory.parseString(makeConfig("exclude_features: [\"lat\"] \n"));
Transform transform = TransformFactory.createTransform(config, "test_quantize");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 2);
Set<String> out = stringFeatures.get("loc_quantized");
log.info("quantize output");
for (String string : out) {
log.info(string);
}
assertTrue(out.size() == 5);
assertTrue(out.contains("long[1.0]=40.0"));
assertTrue(out.contains("long[10.0]=40.0"));
assertTrue(out.contains("zero=0"));
assertTrue(out.contains("negative[1.0]=-1.0"));
assertTrue(out.contains("negative[10.0]=0.0"));
}
@Test
public void testSelectAndExcludeFeatures() {
Config config = ConfigFactory.parseString(
makeConfig("select_features: [\"lat\", \"long\"] \n" + "exclude_features: [\"lat\"] \n"));
Transform transform = TransformFactory.createTransform(config, "test_quantize");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 2);
Set<String> out = stringFeatures.get("loc_quantized");
log.info("quantize output");
for (String string : out) {
log.info(string);
}
assertTrue(out.size() == 2);
assertTrue(out.contains("long[1.0]=40.0"));
assertTrue(out.contains("long[10.0]=40.0"));
}
}
| 7,146 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/CutFloatTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Map;
import java.util.Set;
import static org.junit.Assert.*;
public class CutFloatTransformTest {
private static final Logger log = LoggerFactory.getLogger(CapFloatTransformTest.class);
public String makeConfig() {
return "test_cut {\n" +
" transform : cut_float\n" +
" field1 : loc\n" +
" upper_bound : 39.0\n" +
" keys : [lat,long,z,aaa]\n" +
"}";
}
public String makeConfigWithOutput() {
return "test_cut {\n" +
" transform : cut_float\n" +
" field1 : loc\n" +
" lower_bound : 1.0\n" +
" upper_bound : 39.0\n" +
" keys : [lat,long,z,aaa]\n" +
" output : new_output \n" +
"}";
}
public String makeConfigWithLowerBoundOnly() {
return "test_cut {\n" +
" transform : cut_float\n" +
" field1 : loc\n" +
" lower_bound : 1.0\n" +
" keys : [lat,long,z,aaa]\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_cut");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_cut");
FeatureVector featureVector = TransformTestingHelper.makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 1);
Map<String, Double> feat1 = featureVector.getFloatFeatures().get("loc");
assertEquals(2, feat1.size());
assertEquals(37.7, feat1.get("lat"), 0.1);
assertNull(feat1.get("long"));
assertEquals(-20.0, feat1.get("z"), 0.1);
}
@Test
public void testTransformWithNewOutput() {
Config config = ConfigFactory.parseString(makeConfigWithOutput());
Transform transform = TransformFactory.createTransform(config, "test_cut");
FeatureVector featureVector = TransformTestingHelper.makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 1);
// original feature should not change
Map<String, Double> feat1 = featureVector.getFloatFeatures().get("loc");
assertEquals(3, feat1.size());
assertEquals(37.7, feat1.get("lat"), 0.1);
assertEquals(40.0, feat1.get("long"), 0.1);
assertEquals(-20, feat1.get("z"), 0.1);
// capped features are in a new feature family
assertTrue(featureVector.getFloatFeatures().containsKey("new_output"));
Map<String, Double> feat2 = featureVector.getFloatFeatures().get("new_output");
assertEquals(1, feat2.size());
assertEquals(37.7, feat2.get("lat"), 0.1);
assertNull(feat2.get("long"));
assertNull(feat2.get("z"));
}
@Test
public void testTransformLowerBoundOnly() {
Config config = ConfigFactory.parseString(makeConfigWithLowerBoundOnly());
Transform transform = TransformFactory.createTransform(config, "test_cut");
FeatureVector featureVector = TransformTestingHelper.makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 1);
Map<String, Double> feat1 = featureVector.getFloatFeatures().get("loc");
assertEquals(2, feat1.size());
assertEquals(37.7, feat1.get("lat"), 0.1);
assertEquals(40.0, feat1.get("long"), 0.1);
assertNull(feat1.get("z"));
}
} | 7,147 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/NormalizeUtf8TransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import java.text.Normalizer;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
/**
* Created by christhetree on 1/27/16.
*/
public class NormalizeUtf8TransformTest {
private static final Logger log = LoggerFactory.getLogger(NormalizeUtf8TransformTest.class);
public String makeConfigWithoutNormalizationFormAndOutput() {
return "test_normalize_utf_8 {\n" +
" transform: normalize_utf_8\n" +
" field1: strFeature1\n" +
"}";
}
public String makeConfigWithNormalizationForm(String normalizationForm) {
return "test_normalize_utf_8 {\n" +
" transform: normalize_utf_8\n" +
" field1: strFeature1\n" +
" normalization_form: " + normalizationForm + "\n" +
" output: bar\n" +
"}";
}
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Set<String> list = new HashSet<>();
list.add("Funky string: \u03D3\u03D4\u1E9B");
stringFeatures.put("strFeature1", list);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
return featureVector;
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfigWithoutNormalizationFormAndOutput());
Transform transform = TransformFactory.createTransform(config, "test_normalize_utf_8");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransformDefaultNormalizationFormAndOverwriteInput() {
Config config = ConfigFactory.parseString(makeConfigWithoutNormalizationFormAndOutput());
Transform transform = TransformFactory.createTransform(config, "test_normalize_utf_8");
FeatureVector featureVector = makeFeatureVector();
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
transform.doTransform(featureVector);
assertNotNull(stringFeatures);
assertEquals(1, stringFeatures.size());
Set<String> output = stringFeatures.get("strFeature1");
assertNotNull(output);
assertEquals(1, output.size());
assertTrue(output.contains(Normalizer.normalize(
"Funky string: \u03D3\u03D4\u1E9B", NormalizeUtf8Transform.DEFAULT_NORMALIZATION_FORM)));
}
@Test
public void testTransformNfcNormalizationForm() {
Config config = ConfigFactory.parseString(makeConfigWithNormalizationForm("NFC"));
Transform transform = TransformFactory.createTransform(config, "test_normalize_utf_8");
FeatureVector featureVector = makeFeatureVector();
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
transform.doTransform(featureVector);
assertNotNull(stringFeatures);
assertEquals(2, stringFeatures.size());
Set<String> output = stringFeatures.get("bar");
assertNotNull(output);
assertEquals(1, output.size());
assertTrue(output.contains("Funky string: \u03D3\u03D4\u1E9B"));
assertTrue(Normalizer.isNormalized("Funky string: \u03D3\u03D4\u1E9B", Normalizer.Form.NFC));
}
@Test
public void testTransformNfdNormalizationForm() {
Config config = ConfigFactory.parseString(makeConfigWithNormalizationForm("NFD"));
Transform transform = TransformFactory.createTransform(config, "test_normalize_utf_8");
FeatureVector featureVector = makeFeatureVector();
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
transform.doTransform(featureVector);
assertNotNull(stringFeatures);
assertEquals(2, stringFeatures.size());
Set<String> output = stringFeatures.get("bar");
assertNotNull(output);
assertEquals(1, output.size());
assertTrue(output.contains("Funky string: \u03D2\u0301\u03D2\u0308\u017F\u0307"));
assertTrue(Normalizer.isNormalized(
"Funky string: \u03D2\u0301\u03D2\u0308\u017F\u0307", Normalizer.Form.NFD));
}
@Test
public void testTransformNfkcNormalizationForm() {
Config config = ConfigFactory.parseString(makeConfigWithNormalizationForm("NFKC"));
Transform transform = TransformFactory.createTransform(config, "test_normalize_utf_8");
FeatureVector featureVector = makeFeatureVector();
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
transform.doTransform(featureVector);
assertNotNull(stringFeatures);
assertEquals(2, stringFeatures.size());
Set<String> output = stringFeatures.get("bar");
assertNotNull(output);
assertEquals(1, output.size());
assertTrue(output.contains("Funky string: \u038e\u03ab\u1e61"));
assertTrue(Normalizer.isNormalized("Funky string: \u038e\u03ab\u1e61", Normalizer.Form.NFKC));
}
@Test
public void testTransformNfkdNormalizationForm() {
Config config = ConfigFactory.parseString(makeConfigWithNormalizationForm("NFKD"));
Transform transform = TransformFactory.createTransform(config, "test_normalize_utf_8");
FeatureVector featureVector = makeFeatureVector();
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
transform.doTransform(featureVector);
assertNotNull(stringFeatures);
assertEquals(2, stringFeatures.size());
Set<String> output = stringFeatures.get("bar");
assertNotNull(output);
assertEquals(1, output.size());
assertTrue(output.contains("Funky string: \u03a5\u0301\u03a5\u0308\u0073\u0307"));
assertTrue(Normalizer.isNormalized(
"Funky string: \u03a5\u0301\u03a5\u0308\u0073\u0307", Normalizer.Form.NFKD));
}
}
| 7,148 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/CustomRangeQuantizeTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertTrue;
public class CustomRangeQuantizeTransformTest {
private static final Logger log = LoggerFactory.getLogger(CustomRangeQuantizeTransformTest.class);
private FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("bbb");
stringFeatures.put("strFeature1", list);
Map<String, Double> map = new HashMap<>();
map.put("short", 3.0);
map.put("med", 8.0);
map.put("long", 30.0);
map.put("low_bound", 7.0);
map.put("high_bound", 28.0);
floatFeatures.put("trip", map);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public String makeConfig(String input) {
return "test_quantize {\n" +
" transform : custom_range_quantize\n" +
" field1 : trip\n" + input +
" thresholds : [7.0, 28.0]\n" +
" output : trip_quantized\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig(""));
Transform transform = TransformFactory.createTransform(config, "test_quantize");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig(""));
Transform transform = TransformFactory.createTransform(config, "test_quantize");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 2);
assertTrue(stringFeatures.keySet().contains("trip_quantized"));
assertTrue(stringFeatures.keySet().contains("strFeature1"));
Set<String> out = stringFeatures.get("trip_quantized");
assertTrue(out.size() == 5);
assertTrue(out.contains("short<=7.0"));
assertTrue(out.contains("low_bound<=7.0"));
assertTrue(out.contains("7.0<med<=28.0"));
assertTrue(out.contains("long>28.0"));
assertTrue(out.contains("7.0<high_bound<=28.0"));
}
@Test
public void testSelectFeatures() {
Config config = ConfigFactory.parseString(makeConfig("select_features: [\"short\"] \n"));
Transform transform = TransformFactory.createTransform(config, "test_quantize");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 2);
Set<String> out = stringFeatures.get("trip_quantized");
assertTrue(out.size() == 1);
assertTrue(out.contains("short<=7.0"));
}
}
| 7,149 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/DeleteFloatFeatureTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class DeleteFloatFeatureTransformTest {
private static final Logger log = LoggerFactory.getLogger(DeleteFloatFeatureTransformTest.class);
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("bbb");
stringFeatures.put("strFeature1", list);
Map<String, Double> map = new HashMap<>();
map.put("lat", 37.7);
map.put("long", 40.0);
floatFeatures.put("loc", map);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public String makeConfig() {
return "test_delete {\n" +
" transform : delete_float_feature\n" +
" field1 : loc\n" +
" keys : [long,aaa]\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_delete");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_delete");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 1);
Map<String, Double> feat1 = featureVector.getFloatFeatures().get("loc");
assertEquals(feat1.get("lat"), 37.7, 0.1);
assertTrue(!feat1.containsKey("long"));
}
} | 7,150 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/ProductTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class ProductTransformTest {
private static final Logger log = LoggerFactory.getLogger(ProductTransformTest.class);
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Map<String, Double> map = new HashMap<>();
map.put("lat", 37.7);
map.put("long", 40.0);
map.put("foo", 7.0);
floatFeatures.put("loc", map);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public String makeConfig() {
return "test_prod {\n" +
" transform : product\n" +
" field1 : loc\n" +
" keys: [lat,long]\n" +
" output : loc_prod\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_prod");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_prod");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
assertTrue(floatFeatures.size() == 2);
Map<String, Double> out = floatFeatures.get("loc_prod");
assertTrue(out.size() == 1);
assertEquals((1 + 37.7)*(1+40.0), out.get("*"), 0.1);
}
} | 7,151 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/WtaTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertTrue;
public class WtaTransformTest {
private static final Logger log = LoggerFactory.getLogger(WtaTransformTest.class);
public FeatureVector makeFeatureVector() {
Map<String, List<Double>> denseFeatures = new HashMap<>();
List<Double> feature = new ArrayList<>();
List<Double> feature2 = new ArrayList<>();
for (int i = 0; i < 100; i++) {
feature.add(0.1 * i);
feature2.add(-0.1 * i);
}
denseFeatures.put("a", feature);
denseFeatures.put("b", feature2);
FeatureVector featureVector = new FeatureVector();
featureVector.setDenseFeatures(denseFeatures);
return featureVector;
}
public String makeConfig() {
return "test_wta {\n" +
" transform : wta\n" +
" field_names : [ a, b ]\n" +
" output : wta\n" +
" seed : 1234\n" +
" num_words_per_feature : 4\n" +
" num_tokens_per_word : 4\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_wta");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_wta");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
log.info(featureVector.toString());
assertTrue(featureVector.stringFeatures != null);
Set<String> wta = featureVector.stringFeatures.get("wta");
assertTrue(wta != null);
assertTrue(wta.size() == 8);
assertTrue(wta.contains("a0:71"));
assertTrue(wta.contains("a1:60"));
assertTrue(wta.contains("a2:81"));
assertTrue(wta.contains("a3:103"));
assertTrue(wta.contains("b0:34"));
assertTrue(wta.contains("b1:107"));
assertTrue(wta.contains("b2:7"));
assertTrue(wta.contains("b3:193"));
}
}
| 7,152 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/ConvertStringCaseTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
/**
* Created by christhetree on 1/27/16.
*/
public class ConvertStringCaseTransformTest {
private static final Logger log = LoggerFactory.getLogger(ConvertStringCaseTransformTest.class);
public String makeConfig(boolean convertToUppercase, boolean overwriteInput) {
StringBuilder sb = new StringBuilder();
sb.append("test_convert_string_case {\n");
sb.append(" transform: convert_string_case\n");
sb.append(" field1: strFeature1\n");
sb.append(" convert_to_uppercase: ");
sb.append(Boolean.toString(convertToUppercase));
sb.append("\n");
if (!overwriteInput) {
sb.append(" output: bar\n");
}
sb.append("}");
return sb.toString();
}
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Set<String> list = new HashSet<>();
list.add("I like BLUEBERRY pie, APPLE pie; and I also like BLUE!");
list.add("I'm so excited: I like blue!?!!");
stringFeatures.put("strFeature1", list);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
return featureVector;
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig(false, false));
Transform transform = TransformFactory.createTransform(config, "test_convert_string_case");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransformConvertToLowercase() {
Config config = ConfigFactory.parseString(makeConfig(false, false));
Transform transform = TransformFactory.createTransform(config, "test_convert_string_case");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertNotNull(stringFeatures);
assertEquals(2, stringFeatures.size());
Set<String> output = stringFeatures.get("bar");
assertNotNull(output);
assertEquals(2, output.size());
assertTrue(output.contains("i like blueberry pie, apple pie; and i also like blue!"));
assertTrue(output.contains("i'm so excited: i like blue!?!!"));
}
@Test
public void testTransformConvertToUppercase() {
Config config = ConfigFactory.parseString(makeConfig(true, false));
Transform transform = TransformFactory.createTransform(config, "test_convert_string_case");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertNotNull(stringFeatures);
assertEquals(2, stringFeatures.size());
Set<String> output = stringFeatures.get("bar");
assertNotNull(output);
assertEquals(2, output.size());
assertTrue(output.contains("I LIKE BLUEBERRY PIE, APPLE PIE; AND I ALSO LIKE BLUE!"));
assertTrue(output.contains("I'M SO EXCITED: I LIKE BLUE!?!!"));
}
@Test
public void testTransformOverwriteInput() {
Config config = ConfigFactory.parseString(makeConfig(true, true));
Transform transform = TransformFactory.createTransform(config, "test_convert_string_case");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertNotNull(stringFeatures);
assertEquals(1, stringFeatures.size());
Set<String> output = stringFeatures.get("strFeature1");
assertNotNull(output);
assertEquals(2, output.size());
assertTrue(output.contains("I LIKE BLUEBERRY PIE, APPLE PIE; AND I ALSO LIKE BLUE!"));
assertTrue(output.contains("I'M SO EXCITED: I LIKE BLUE!?!!"));
}
}
| 7,153 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/TransformTestingHelper.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
public class TransformTestingHelper {
public static FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("bbb");
stringFeatures.put("strFeature1", list);
Map<String, Double> map = new HashMap<>();
map.put("lat", 37.7);
map.put("long", 40.0);
map.put("z", -20.0);
floatFeatures.put("loc", map);
Map<String, Double> map2 = new HashMap<>();
map2.put("foo", 1.5);
floatFeatures.put("F", map2);
Map<String, Double> map3 = new HashMap<>();
map3.put("bar_fv", 1.0);
floatFeatures.put("bar", map3);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
}
| 7,154 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/CrossTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class CrossTransformTest {
private static final Logger log = LoggerFactory.getLogger(CrossTransformTest.class);
public FeatureVector makeFeatureVector() {
HashMap stringFeatures = new HashMap<String, Set<String>>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("bbb");
stringFeatures.put("feature1", list);
Set list2 = new HashSet<String>();
list2.add("11");
list2.add("22");
stringFeatures.put("feature2", list2);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
return featureVector;
}
public String makeConfig() {
return "test_cross {\n" +
" transform : cross\n" +
" field1 : feature1\n" +
" field2 : feature2\n" +
" output : out\n" +
"}";
}
public String makeKey1Config() {
return "test_cross {\n" +
" transform : cross\n" +
" field1 : feature1\n" +
" keys1 : [aaa]\n" +
" field2 : feature2\n" +
" output : out\n" +
"}";
}
public String makeBothKeyConfig() {
return "test_cross {\n" +
" transform : cross\n" +
" field1 : feature1\n" +
" keys1 : [aaa]\n" +
" field2 : feature2\n" +
" keys2 : [22]\n" +
" output : out\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_cross");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_cross");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 3);
Set<String> out = stringFeatures.get("out");
assertTrue(out.size() == 4);
log.info("Cross output");
for (String string : out) {
log.info(string);
}
assertTrue(out.contains("aaa^11"));
assertTrue(out.contains("aaa^22"));
assertTrue(out.contains("bbb^11"));
assertTrue(out.contains("bbb^22"));
}
@Test
public void testOneKeyTransform() {
Config config = ConfigFactory.parseString(makeKey1Config());
Transform transform = TransformFactory.createTransform(config, "test_cross");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 3);
Set<String> out = stringFeatures.get("out");
log.info("Cross output");
for (String string : out) {
log.info(string);
}
assertEquals(2, out.size());
assertTrue(out.contains("aaa^11"));
assertTrue(out.contains("aaa^22"));
}
@Test
public void testTwoKeysTransform() {
Config config = ConfigFactory.parseString(makeBothKeyConfig());
Transform transform = TransformFactory.createTransform(config, "test_cross");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 3);
Set<String> out = stringFeatures.get("out");
log.info("Cross output");
for (String string : out) {
log.info(string);
}
assertEquals(1, out.size());
assertTrue(out.contains("aaa^22"));
}
}
| 7,155 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/FloatToDenseTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static junit.framework.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
@Slf4j
public class FloatToDenseTransformTest {
public String makeConfig() {
return "test_float_cross_float {\n" +
" transform : float_to_dense\n" +
" fields : [floatFeature1,floatFeature1,floatFeature2]\n" +
" keys : [x,y,z]\n" +
" string_output : string\n" +
"}";
}
public String notStringConfig() {
return "test_float_cross_float {\n" +
" transform : float_to_dense\n" +
" fields : [floatFeature1,floatFeature1,floatFeature2]\n" +
" keys : [x,y,z]\n" +
"}";
}
public static FeatureVector makeFeatureVectorFull() {
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Map<String, Double> floatFeature1 = new HashMap<>();
floatFeature1.put("x", 50.0);
floatFeature1.put("y", 1.3);
floatFeature1.put("s", 2000.0);
Map<String, Double> floatFeature2 = new HashMap<>();
floatFeature2.put("z", 2000.0);
floatFeature2.put("k", 2000.0);
floatFeatures.put("floatFeature1", floatFeature1);
floatFeatures.put("floatFeature2", floatFeature2);
FeatureVector featureVector = new FeatureVector();
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public static FeatureVector makeFeatureVectorMissFamily() {
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Map<String, Double> floatFeature1 = new HashMap<>();
floatFeature1.put("x", 50.0);
floatFeature1.put("y", 1.3);
floatFeature1.put("s", 2000.0);
floatFeatures.put("floatFeature1", floatFeature1);
FeatureVector featureVector = new FeatureVector();
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public FeatureVector makeFeatureVectorPartial() {
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Map<String, Double> floatFeature1 = new HashMap<>();
floatFeature1.put("x", 50.0);
floatFeature1.put("s", 2000.0);
Map<String, Double> floatFeature2 = new HashMap<>();
floatFeature2.put("z", 2000.0);
floatFeature2.put("k", 2000.0);
floatFeatures.put("floatFeature1", floatFeature1);
floatFeatures.put("floatFeature2", floatFeature2);
FeatureVector featureVector = new FeatureVector();
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public FeatureVector makeFeatureVectorFloat() {
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Map<String, Double> floatFeature1 = new HashMap<>();
floatFeature1.put("x", 50.0);
floatFeature1.put("s", 2000.0);
Map<String, Double> floatFeature2 = new HashMap<>();
floatFeature2.put("k", 2000.0);
floatFeatures.put("floatFeature1", floatFeature1);
floatFeatures.put("floatFeature2", floatFeature2);
FeatureVector featureVector = new FeatureVector();
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public FeatureVector makeFeatureVectorString() {
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Map<String, Double> floatFeature1 = new HashMap<>();
floatFeature1.put("s", 2000.0);
Map<String, Double> floatFeature2 = new HashMap<>();
floatFeature2.put("k", 2000.0);
floatFeatures.put("floatFeature1", floatFeature1);
floatFeatures.put("floatFeature2", floatFeature2);
FeatureVector featureVector = new FeatureVector();
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_float_cross_float");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getFloatFeatures() == null);
}
@Test
public void testFull() {
FeatureVector featureVector = testTransform(makeFeatureVectorFull());
Map<String, List<Double>> denseFeatures = featureVector.getDenseFeatures();
assertNotNull(denseFeatures);
assertEquals(1, denseFeatures.size());
List<Double> out = denseFeatures.get("x^y^z");
assertEquals(3, out.size());
assertEquals(50.0, out.get(0), 0.01);
assertEquals(1.3, out.get(1), 0.01);
assertEquals(2000, out.get(2), 0.01);
}
@Test
public void testMissFamily() {
FeatureVector featureVector = testTransform(makeFeatureVectorMissFamily());
Map<String, List<Double>> denseFeatures = featureVector.getDenseFeatures();
assertNull(denseFeatures);
}
@Test
public void testPartial() {
FeatureVector featureVector = testTransform(makeFeatureVectorPartial());
Map<String, List<Double>> denseFeatures = featureVector.getDenseFeatures();
assertNull(denseFeatures);
}
@Test
public void testFloat() {
FeatureVector featureVector = testTransform(makeFeatureVectorFloat());
Map<String, Map<String, Double>> features = featureVector.getFloatFeatures();
assertNotNull(features);
assertEquals(2, features.size());
Map<String, Double> out = features.get("floatFeature1");
assertEquals(2, out.size());
}
@Test
public void testNoString() {
FeatureVector featureVector = testTransform(makeFeatureVectorString(), notStringConfig());
Map<String, Set<String>> features = featureVector.getStringFeatures();
assertNull(features);
}
public FeatureVector testTransform(FeatureVector featureVector) {
return testTransform(featureVector, makeConfig());
}
public static FeatureVector testTransform(FeatureVector featureVector, String cfg) {
Config config = ConfigFactory.parseString(cfg);
Transform transform = TransformFactory.createTransform(config, "test_float_cross_float");
transform.doTransform(featureVector);
return featureVector;
}
}
| 7,156 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/LinearLogQuantizeTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class LinearLogQuantizeTransformTest {
private static final Logger log = LoggerFactory.getLogger(LinearLogQuantizeTransformTest.class);
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("bbb");
stringFeatures.put("strFeature1", list);
Map<String, Double> map = new HashMap<>();
map.put("a", 0.0);
map.put("b", 0.13);
map.put("c", 1.23);
map.put("d", 5.0);
map.put("e", 17.5);
map.put("f", 99.98);
map.put("g", 365.0);
map.put("h", 65537.0);
map.put("i", -1.0);
map.put("j", -23.0);
floatFeatures.put("loc", map);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public String makeConfig() {
return "test_quantize {\n" +
" transform : linear_log_quantize\n" +
" field1 : loc\n" +
" scale : 10\n" +
" output : loc_quantized\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_quantize");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_quantize");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 2);
Set<String> out = stringFeatures.get("loc_quantized");
assertTrue(out.size() == 10);
log.info("quantize output");
for (String string : out) {
log.info(string);
}
assertTrue(out.contains("a=0"));
assertTrue(out.contains("b=0.125"));
assertTrue(out.contains("c=1.125"));
assertTrue(out.contains("d=5.0"));
assertTrue(out.contains("e=17.5"));
assertTrue(out.contains("f=90"));
assertTrue(out.contains("g=350"));
assertTrue(out.contains("h=65536"));
assertTrue(out.contains("i=-1.0"));
assertTrue(out.contains("j=-23.0"));
}
} | 7,157 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/MultiscaleMoveFloatToStringTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class MultiscaleMoveFloatToStringTransformTest {
private static final Logger log = LoggerFactory.getLogger(MultiscaleMoveFloatToStringTransformTest.class);
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("bbb");
stringFeatures.put("strFeature1", list);
Map<String, Double> map = new HashMap<>();
map.put("lat", 37.7);
map.put("long", 40.0);
floatFeatures.put("loc", map);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public String makeConfig() {
return "test_quantize {\n" +
" transform : multiscale_move_float_to_string\n" +
" field1 : loc\n" +
" buckets : [1.0, 10.0]\n" +
" keys : [lat]\n" +
" output : loc_quantized\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_quantize");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_quantize");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 2);
Set<String> out = stringFeatures.get("loc_quantized");
log.info("quantize output");
for (String string : out) {
log.info(string);
}
assertTrue(out.size() == 2);
assertTrue(out.contains("lat[1.0]=37.0"));
assertTrue(out.contains("lat[10.0]=30.0"));
}
} | 7,158 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/SelfCrossTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashSet;
import java.util.Set;
import java.util.HashMap;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class SelfCrossTransformTest {
private static final Logger log = LoggerFactory.getLogger(SelfCrossTransformTest.class);
public FeatureVector makeFeatureVector() {
HashMap stringFeatures = new HashMap<String, Set<String>>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("bbb");
stringFeatures.put("feature1", list);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
return featureVector;
}
public String makeConfig() {
return "test_cross {\n" +
" transform : self_cross\n" +
" field1 : feature1\n" +
" output : out\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_cross");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_cross");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 2);
Set<String> out = stringFeatures.get("out");
log.info("Cross output");
for (String string : out) {
log.info(string);
}
assertTrue(out.size() == 1);
assertTrue(out.contains("aaa^bbb"));
}
} | 7,159 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/DateDiffTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.LoggerFactory;
import org.slf4j.Logger;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
/**
* Created by seckcoder on 12/17/15.
*/
public class DateDiffTransformTest {
private static final Logger log = LoggerFactory.getLogger(DateDiffTransformTest.class);
public String makeConfig() {
return "test_datediff {\n" +
" transform: date_diff\n" +
" field1: endDates\n" +
" field2: startDates\n" +
" output: bar\n" +
"}";
}
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set endDates = new HashSet<String>();
Set startDates = new HashSet<String>();
endDates.add("2009-03-01");
startDates.add("2009-02-27");
stringFeatures.put("endDates", endDates);
stringFeatures.put("startDates", startDates);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_datediff");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
assertTrue(floatFeatures.size() == 1);
Map<String, Double> out = floatFeatures.get("bar");
assertEquals(2, out.get("2009-03-01-m-2009-02-27").intValue());
}
}
| 7,160 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/MultiscaleQuantizeTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class MultiscaleQuantizeTransformTest {
private static final Logger log = LoggerFactory.getLogger(MultiscaleQuantizeTransformTest.class);
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("bbb");
stringFeatures.put("strFeature1", list);
Map<String, Double> map = new HashMap<>();
map.put("lat", 37.7);
map.put("long", 40.0);
map.put("zero", 0.0);
map.put("negative", -1.0);
floatFeatures.put("loc", map);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public String makeConfig() {
return "test_quantize {\n" +
" transform : multiscale_quantize\n" +
" field1 : loc\n" +
" buckets : [1, 10]\n" +
" output : loc_quantized\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_quantize");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_quantize");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 2);
Set<String> out = stringFeatures.get("loc_quantized");
log.info("quantize output");
for (String string : out) {
log.info(string);
}
assertTrue(out.size() == 7);
assertTrue(out.contains("lat[10.0]=30.0"));
assertTrue(out.contains("long[1.0]=40.0"));
assertTrue(out.contains("long[10.0]=40.0"));
assertTrue(out.contains("lat[1.0]=37.0"));
assertTrue(out.contains("zero=0"));
assertTrue(out.contains("negative[1.0]=-1.0"));
assertTrue(out.contains("negative[10.0]=0.0"));
}
} | 7,161 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/ApproximatePercentileTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class ApproximatePercentileTransformTest {
private static final Logger log = LoggerFactory.getLogger(ApproximatePercentileTransformTest.class);
public FeatureVector makeFeatureVector(double low, double high, double val) {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("bbb");
stringFeatures.put("strFeature1", list);
Map<String, Double> map = new HashMap<>();
map.put("10th", low);
map.put("90th", high);
floatFeatures.put("DECILES", map);
Map<String, Double> map2 = new HashMap<>();
map2.put("foo", val);
floatFeatures.put("F", map2);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public String makeConfig() {
return "test_approximate_percentile {\n" +
" transform : approximate_percentile\n" +
" field1 : DECILES\n" +
" low : 10th\n" +
" upper : 90th\n" +
" minDiff : 10 \n" +
" field2 : F\n" +
" key2 : foo\n" +
" output : PERCENTILE\n" +
" outputKey : percentile\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_approximate_percentile");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_approximate_percentile");
double[] values = { -1.0, 10.0, 15.0, 20.0, 50.0, 60.0, 100.0, 200.0 };
double[] expected = { 0.0, 0.0, 0.05, 0.11, 0.44, 0.55, 1.0, 1.0 };
for (int i = 0; i < values.length; i++) {
double val = values[i];
FeatureVector featureVector = makeFeatureVector(10.0, 100.0, val);
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 1);
Map<String, Double> out = featureVector.floatFeatures.get("PERCENTILE");
assertTrue(out.size() == 1);
assertEquals(expected[i], out.get("percentile"), 0.01);
}
}
@Test
public void testAbstain() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_approximate_percentile");
FeatureVector featureVector = makeFeatureVector(10.0, 11.0, 1.0);
transform.doTransform(featureVector);
assertTrue(featureVector.floatFeatures.get("PERCENTILE") == null);
}
} | 7,162 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/ReplaceAllStringsTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
/**
* Created by christhetree on 1/27/16.
*/
public class ReplaceAllStringsTransformTest {
private static final Logger log = LoggerFactory.getLogger(ReplaceAllStringsTransformTest.class);
public String makeConfig(List<Map<String, String>> replacements, boolean overwriteInput) {
StringBuilder sb = new StringBuilder();
sb.append("test_replace_all_strings {\n");
sb.append(" transform: replace_all_strings\n");
sb.append(" field1: strFeature1\n");
sb.append(" replacements: [\n");
for (Map<String, String> replacementMap : replacements) {
for (Map.Entry<String, String> replacementEntry : replacementMap.entrySet()) {
sb.append("{ \"");
sb.append(replacementEntry.getKey());
sb.append("\": \"");
sb.append(replacementEntry.getValue());
sb.append("\" }\n");
}
}
sb.append(" ]\n");
if (!overwriteInput) {
sb.append(" output: bar\n");
}
sb.append("}");
return sb.toString();
}
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Set<String> list = new HashSet<>();
list.add("I like blueberry pie, apple pie; and I also like blue!");
list.add("I'm so excited: I like blue!?!!");
stringFeatures.put("strFeature1", list);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
return featureVector;
}
public List<Map<String, String>> makeReplacements() {
List<Map<String, String>> replacements = new ArrayList<>();
Map<String, String> replacement1 = new HashMap<>();
replacement1.put("I ", "you ");
Map<String, String> replacement2 = new HashMap<>();
replacement2.put("blue", "yellow");
Map<String, String> replacement3 = new HashMap<>();
replacement3.put("yellow", "black");
replacements.add(replacement1);
replacements.add(replacement2);
replacements.add(replacement3);
return replacements;
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig(makeReplacements(), false));
Transform transform = TransformFactory.createTransform(config, "test_replace_all_strings");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig(makeReplacements(), false));
Transform transform = TransformFactory.createTransform(config, "test_replace_all_strings");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertNotNull(stringFeatures);
assertEquals(2, stringFeatures.size());
Set<String> output = stringFeatures.get("bar");
assertNotNull(output);
assertEquals(2, output.size());
assertTrue(output.contains("you like blackberry pie, apple pie; and you also like black!"));
assertTrue(output.contains("I'm so excited: you like black!?!!"));
}
@Test
public void testTransformOverwriteInput() {
Config config = ConfigFactory.parseString(makeConfig(makeReplacements(), true));
Transform transform = TransformFactory.createTransform(config, "test_replace_all_strings");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertNotNull(stringFeatures);
assertEquals(1, stringFeatures.size());
Set<String> output = stringFeatures.get("strFeature1");
assertNotNull(output);
assertEquals(2, output.size());
assertTrue(output.contains("you like blackberry pie, apple pie; and you also like black!"));
assertTrue(output.contains("I'm so excited: you like black!?!!"));
}
}
| 7,163 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/MultiscaleGridContinuousTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.assertEquals;
/**
* @author Hector Yee
*/
public class MultiscaleGridContinuousTransformTest {
private static final Logger log = LoggerFactory.getLogger(MultiscaleGridContinuousTransformTest.class);
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("bbb");
stringFeatures.put("strFeature1", list);
Map<String, Double> map = new HashMap<>();
map.put("lat", 37.7);
map.put("long", 40.0);
floatFeatures.put("loc", map);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public String makeConfig() {
return "test_grid {\n" +
" transform : multiscale_grid_continuous\n" +
" field1 : loc\n" +
" value1 : lat\n" +
" value2 : long\n" +
" buckets : [1, 5]\n" +
" output : loc_continuous\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_grid");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_grid");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 1);
Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
assertTrue(floatFeatures.size() == 2);
Map<String, Double> out = floatFeatures.get("loc_continuous");
log.info("grid output");
for (Map.Entry<String, Double> entry : out.entrySet()) {
log.info(entry.getKey() + "=" + entry.getValue());
}
assertEquals(4, out.size());
assertEquals(0.7, out.get("[1.0]=(37.0,40.0)@1"), 0.01);
assertEquals(2.7, out.get("[5.0]=(35.0,40.0)@1"), 0.01);
assertEquals(0.0, out.get("[1.0]=(37.0,40.0)@2"), 0.01);
assertEquals(0.0, out.get("[5.0]=(35.0,40.0)@2"), 0.01);
}
} | 7,164 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/FloatLabelTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import java.util.HashMap;
import java.util.Map;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
public class FloatLabelTransformTest {
private FeatureVector makeFeatureVector(Double value, Double label) {
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
if (value != null) {
Map<String, Double> map = new HashMap<>();
map.put("50th", value);
floatFeatures.put("DECILES", map);
}
if (label != null) {
Map<String, Double> map = new HashMap<>();
map.put("", label);
floatFeatures.put("LABEL", map);
}
FeatureVector featureVector = new FeatureVector();
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
private FloatLabelTransform createTransform(FloatLabelTransform.MergeStrategy mergeStrategy) {
Config config = ConfigFactory.parseString("test_float_label {\n" +
" transform : float_label\n" +
" field1 : DECILES\n" +
" key1 : 50th\n" +
" threshold : 10\n" +
" merge : " + mergeStrategy.toString() + "\n" +
"}");
FloatLabelTransform transform = new FloatLabelTransform();
transform.configure(config, "test_float_label");
return transform;
}
private double getLabel(FeatureVector featureVector) {
return featureVector.floatFeatures.get("LABEL").get("");
}
@Test
public void handleMissingFeature() {
FloatLabelTransform transform = createTransform(FloatLabelTransform.MergeStrategy.OVERRIDE);
// keep current label even though we could overwrite
FeatureVector featureVector1 = makeFeatureVector(null, 1.0);
transform.doTransform(featureVector1);
assertEquals(1, getLabel(featureVector1), 0.1);
}
@Test
public void OverwriteLabel() {
FloatLabelTransform transform = createTransform(FloatLabelTransform.MergeStrategy.OVERRIDE);
// fill in missing positive label
FeatureVector featureVector1 = makeFeatureVector(1.0, null);
transform.doTransform(featureVector1);
assertEquals(-1, getLabel(featureVector1), 0.1);
// fill in missing negative label
FeatureVector featureVector2 = makeFeatureVector(10.0, null);
transform.doTransform(featureVector2);
assertEquals(1, getLabel(featureVector2), 0.1);
// overwrite positive label
FeatureVector featureVector3 = makeFeatureVector(1.0, 1.0);
transform.doTransform(featureVector3);
assertEquals(-1, getLabel(featureVector3), 0.1);
// overwrite negative label
FeatureVector featureVector4 = makeFeatureVector(10.0, -1.0);
transform.doTransform(featureVector4);
assertEquals(1, getLabel(featureVector4), 0.1);
}
@Test
public void keepExistingLabel() {
FloatLabelTransform transform = createTransform(FloatLabelTransform.MergeStrategy.SKIP);
// fill in missing positive label
FeatureVector featureVector1 = makeFeatureVector(1.0, null);
transform.doTransform(featureVector1);
assertEquals(-1, getLabel(featureVector1), 0.1);
// fill in missing negative label
FeatureVector featureVector2 = makeFeatureVector(10.0, null);
transform.doTransform(featureVector2);
assertEquals(1, getLabel(featureVector2), 0.1);
// preserve positive label
FeatureVector featureVector3 = makeFeatureVector(1.0, 1.0);
transform.doTransform(featureVector3);
assertEquals(1, getLabel(featureVector3), 0.1);
// preserve negative label
FeatureVector featureVector4 = makeFeatureVector(10.0, -1.0);
transform.doTransform(featureVector4);
assertEquals(-1, getLabel(featureVector4), 0.1);
}
@Test
public void keepPositiveLabel() {
FloatLabelTransform transform = createTransform(FloatLabelTransform.MergeStrategy.OVERRIDE_NEGATIVE);
// fill in missing positive label
FeatureVector featureVector1 = makeFeatureVector(1.0, null);
transform.doTransform(featureVector1);
assertEquals(-1, getLabel(featureVector1), 0.1);
// fill in missing negative label
FeatureVector featureVector2 = makeFeatureVector(10.0, null);
transform.doTransform(featureVector2);
assertEquals(1, getLabel(featureVector2), 0.1);
// preserve positive label
FeatureVector featureVector3 = makeFeatureVector(1.0, 1.0);
transform.doTransform(featureVector3);
assertEquals(1, getLabel(featureVector3), 0.1);
// overwrite negative label
FeatureVector featureVector4 = makeFeatureVector(10.0, -1.0);
transform.doTransform(featureVector4);
assertEquals(1, getLabel(featureVector4), 0.1);
}
@Test
public void keepNegativeLabel() {
FloatLabelTransform transform = createTransform(FloatLabelTransform.MergeStrategy.OVERRIDE_POSITIVE);
// fill in missing positive label
FeatureVector featureVector1 = makeFeatureVector(1.0, null);
transform.doTransform(featureVector1);
assertEquals(-1, getLabel(featureVector1), 0.1);
// fill in missing negative label
FeatureVector featureVector2 = makeFeatureVector(10.0, null);
transform.doTransform(featureVector2);
assertEquals(1, getLabel(featureVector2), 0.1);
// overwrite positive label
FeatureVector featureVector3 = makeFeatureVector(1.0, 1.0);
transform.doTransform(featureVector3);
assertEquals(-1, getLabel(featureVector3), 0.1);
// preserve negative label
FeatureVector featureVector4 = makeFeatureVector(10.0, -1.0);
transform.doTransform(featureVector4);
assertEquals(-1, getLabel(featureVector4), 0.1);
}
}
| 7,165 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/FloatFamilyCrossToTwoDDenseTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import java.util.List;
import java.util.Map;
import static com.airbnb.aerosolve.core.transforms.FloatToDenseTransformTest.makeFeatureVectorFull;
import static com.airbnb.aerosolve.core.transforms.FloatToDenseTransformTest.makeFeatureVectorMissFamily;
import static junit.framework.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
@Slf4j
public class FloatFamilyCrossToTwoDDenseTransformTest {
public String makeConfig() {
return "test_float_cross_float {\n" +
" transform : float_family_cross_to_two_d_dense\n" +
" field1 : floatFeature1 \n" +
" field2 : floatFeature2 \n" +
"}";
}
public String makeSelfCrossConfig() {
return "test_float_cross_float {\n" +
" transform : float_family_cross_to_two_d_dense\n" +
" field1 : floatFeature1 \n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_float_cross_float");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertNull(featureVector.getFloatFeatures());
}
public FeatureVector testTransform(FeatureVector featureVector) {
return FloatToDenseTransformTest.testTransform(featureVector, makeConfig());
}
@Test
public void testFull() {
FeatureVector featureVector = testTransform(makeFeatureVectorFull());
Map<String, List<Double>> denseFeatures = featureVector.getDenseFeatures();
assertNotNull(denseFeatures);
assertEquals(6, denseFeatures.size());
List<Double> out = denseFeatures.get("x^z");
assertEquals(2, out.size());
assertEquals(50.0, out.get(0), 0.01);
assertEquals(2000, out.get(1), 0.01);
assertNull(denseFeatures.get("x^y"));
assertNotNull(denseFeatures.get("s^k"));
}
@Test
public void testMissFamily() {
FeatureVector featureVector = testTransform(makeFeatureVectorMissFamily());
Map<String, List<Double>> denseFeatures = featureVector.getDenseFeatures();
assertNull(denseFeatures);
}
@Test
public void testSelfCross() {
FeatureVector featureVector = FloatToDenseTransformTest.testTransform(
makeFeatureVectorFull(), makeSelfCrossConfig());
Map<String, List<Double>> denseFeatures = featureVector.getDenseFeatures();
assertNotNull(denseFeatures);
assertEquals(3, denseFeatures.size());
log.debug("dense {}", denseFeatures);
List<Double> out = denseFeatures.get("s^x");
assertEquals(2, out.size());
assertEquals(2000, out.get(0), 0.01);
assertEquals(50.0, out.get(1), 0.01);
assertNull(denseFeatures.get("x^x"));
assertNotNull(denseFeatures.get("s^y"));
assertNotNull(denseFeatures.get("x^y"));
}
}
| 7,166 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/DivideTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Hector Yee
*/
public class DivideTransformTest {
private static final Logger log = LoggerFactory.getLogger(DivideTransformTest.class);
public String makeConfigWithKeys() {
return "test_divide {\n" +
" transform : divide\n" +
" field1 : loc\n" +
" field2 : F\n" +
" keys : [ lat, long ] \n" +
" key2 : foo\n" +
" constant : 0.1\n" +
" output : bar\n" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfigWithKeys());
Transform transform = TransformFactory.createTransform(config, "test_divide");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransformWithKeys() {
Config config = ConfigFactory.parseString(makeConfigWithKeys());
Transform transform = TransformFactory.createTransform(config, "test_divide");
FeatureVector featureVector = TransformTestingHelper.makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 1);
Map<String, Double> out = featureVector.floatFeatures.get("bar");
for (Map.Entry<String, Double> entry : out.entrySet()) {
log.info(entry.getKey() + "=" + entry.getValue());
}
assertTrue(out.size() == 3);
// the existing features under the family "bar" should not be deleted
assertEquals(1.0, out.get("bar_fv"), 0.1);
assertEquals(37.7 / 1.6, out.get("lat-d-foo"), 0.1);
assertEquals(40.0 / 1.6, out.get("long-d-foo"), 0.1);
}
} | 7,167 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/transforms/CustomLinearLogQuantizeTransformTest.java | package com.airbnb.aerosolve.core.transforms;
import com.airbnb.aerosolve.core.FeatureVector;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import static org.junit.Assert.assertTrue;
public class CustomLinearLogQuantizeTransformTest {
private static final Logger log = LoggerFactory.getLogger(CustomLinearLogQuantizeTransformTest.class);
public FeatureVector makeFeatureVector() {
Map<String, Set<String>> stringFeatures = new HashMap<>();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Set list = new HashSet<String>();
list.add("aaa");
list.add("bbb");
stringFeatures.put("strFeature1", list);
Map<String, Double> map = new HashMap<>();
map.put("a", 0.0);
map.put("b", 0.13);
map.put("c", 1.23);
map.put("d", 5.0);
map.put("e", 17.5);
map.put("f", 99.98);
map.put("g", 365.0);
map.put("h", 65537.0);
map.put("i", -1.0);
map.put("j", -23.0);
floatFeatures.put("loc", map);
FeatureVector featureVector = new FeatureVector();
featureVector.setStringFeatures(stringFeatures);
featureVector.setFloatFeatures(floatFeatures);
return featureVector;
}
public String makeConfig() {
return "test_quantize {\n" +
" transform : custom_linear_log_quantize\n" +
" field1 : loc\n" +
" scale : 10\n" +
" output : loc_quantized\n" +
" limit_bucket: [{\"1.0\" : \"0.125\"},\n" +
" {\"10.0\" : \"0.5\"},\n" +
" {\"25.0\" : \"2.0\"}\n" +
" {\"50.0\" : \"5.0\"},\n" +
" {\"100.0\" : \"10.0\"},\n" +
" {\"400.0\" : \"25.0\"},\n" +
" {\"2000.0\" : \"100.0\"},\n" +
" {\"10000.0\" : \"250.0\"}\n" +
" ]" +
"}";
}
@Test
public void testEmptyFeatureVector() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_quantize");
FeatureVector featureVector = new FeatureVector();
transform.doTransform(featureVector);
assertTrue(featureVector.getStringFeatures() == null);
}
@Test
public void testTransform() {
Config config = ConfigFactory.parseString(makeConfig());
Transform transform = TransformFactory.createTransform(config, "test_quantize");
FeatureVector featureVector = makeFeatureVector();
transform.doTransform(featureVector);
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
assertTrue(stringFeatures.size() == 2);
Set<String> out = stringFeatures.get("loc_quantized");
log.info("quantize output");
for (String string : out) {
log.info(string);
}
assertTrue(out.size() == 10);
log.info("quantize output");
for (String string : out) {
log.info(string);
}
assertTrue(out.contains("a=0.0"));
assertTrue(out.contains("b=0.125"));
assertTrue(out.contains("c=1.0"));
assertTrue(out.contains("d=5.0"));
assertTrue(out.contains("e=16.0"));
assertTrue(out.contains("f=90.0"));
assertTrue(out.contains("g=350.0"));
assertTrue(out.contains("h=10000.0"));
assertTrue(out.contains("i=-1.0"));
assertTrue(out.contains("j=-22.0"));
}
} | 7,168 |
0 | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/test/java/com/airbnb/aerosolve/core/scoring/ModelScorerTest.java | package com.airbnb.aerosolve.core.scoring;
import com.airbnb.aerosolve.core.Example;
import com.airbnb.aerosolve.core.FeatureVector;
import com.airbnb.aerosolve.core.features.*;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
@Slf4j
public class ModelScorerTest {
@Test
public void rawProbability() throws Exception {
ModelConfig incomeModel = ModelConfig.builder()
.modelName("income.model")
.configName("income_prediction.conf")
.key("spline_model")
.build();
ModelScorer modelScorer = new ModelScorer(incomeModel);
FeatureMapping featureMapping = new FeatureMapping();
featureMapping.add(dataName1);
featureMapping.add(dataName2);
featureMapping.add(dataName3);
featureMapping.finish();
FeatureGen f = new FeatureGen(featureMapping);
f.add(data1, dataName1);
f.add(data2, dataName2);
f.add(data3, dataName3);
Features features = f.gen();
List<StringFamily> stringFamilies = new ArrayList<>();
stringFamilies.add(new StringFamily("S"));
List<FloatFamily> floatFamilies = new ArrayList<>();
floatFamilies.add(new FloatFamily("F"));
Example example = FeatureVectorGen.toSingleFeatureVectorExample(features, stringFamilies, floatFamilies);
FeatureVector featureVector = example.getExample().get(0);
final Map<String, Map<String, Double>> floatFeatures = featureVector.getFloatFeatures();
Map<String, Double> floatFeatureFamily = floatFeatures.get("F");
assertEquals(floatFeatureFamily.get("age"), 30, 0.1);
assertEquals(floatFeatureFamily.get("hours"), 40, 0.1);
final Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
Set<String> stringFeatureFamily = stringFeatures.get("S");
assertFalse(stringFeatureFamily.contains("marital-status"));
assertTrue(stringFeatureFamily.contains("married"));
double score = modelScorer.score(example);
log.info("score {}", score);
}
private static final String[] dataName1 = {"age", "fnlwgt", "edu-num"};
private static final float[] data1 = {30, 10, 10};
private static final String[] dataName2 = {"capital-gain", "capital-loss", "hours"};
private static final float[] data2 = {3000, 1000, 40};
private static final String[] dataName3 = {
"workclass", "education", "marital-status",
"occupation", "relationship", "race", "sex",
"native-country"
};
private static final String[] data3 = {
"scientist", "collage", "married",
"engineer", "single", "asian", "female",
"usa"
};
} | 7,169 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/util/FeatureDictionary.java | package com.airbnb.aerosolve.core.util;
import com.airbnb.aerosolve.core.FeatureVector;
import lombok.Getter;
import lombok.Setter;
import java.io.Serializable;
import java.util.*;
import java.util.AbstractMap.SimpleEntry;
import java.util.Map.Entry;
/**
* A class that maintains a dictionary of features and returns
* the responses of a new feature to each element in the dictionary.
*/
public abstract class FeatureDictionary implements Serializable {
/**
* The dictionary to maintain
*/
@Setter
protected List<FeatureVector> dictionaryList;
public FeatureDictionary() {
}
class EntryComparator implements Comparator<Entry<String, Double>> {
public int compare(Entry<String, Double> e1,
Entry<String, Double> e2) {
if (e1.getValue() > e2.getValue()) {
return 1;
} else if (e1.getValue() < e2.getValue()) {
return -1;
}
return 0;
}
}
/**
* Returns the k-nearest neighbors as floatFeatures in featureVector.
*/
public abstract FeatureVector getKNearestNeighbors(
KNearestNeighborsOptions options,
FeatureVector featureVector);
} | 7,170 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/util/Util.java | package com.airbnb.aerosolve.core.util;
/**
* @author hector_yee
*
* Utilities for machine learning
*/
import com.airbnb.aerosolve.core.DebugScoreDiffRecord;
import com.airbnb.aerosolve.core.DebugScoreRecord;
import com.airbnb.aerosolve.core.Example;
import com.airbnb.aerosolve.core.FeatureVector;
import com.airbnb.aerosolve.core.KDTreeNode;
import com.airbnb.aerosolve.core.ModelRecord;
import lombok.extern.slf4j.Slf4j;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.stream.Stream;
import java.util.zip.GZIPInputStream;
import com.google.common.hash.HashCode;
import com.google.common.hash.Hasher;
import com.google.common.hash.Hashing;
import org.apache.commons.codec.binary.Base64;
import org.apache.thrift.TBase;
import org.apache.thrift.TDeserializer;
import org.apache.thrift.TSerializer;
@Slf4j
public class Util implements Serializable {
private static double LOG2 = Math.log(2);
// Coder / decoder utilities for various protos. This makes it easy to
// manipulate in spark. e.g. if we wanted to see the 50 weights in a model
// val top50 = sc.textFile("model.bz2").map(Util.decodeModel).sortBy(x => -x.weight).take(50);
public static String encode(TBase obj) {
TSerializer serializer = new TSerializer();
try {
byte[] bytes = serializer.serialize(obj);
return new String(Base64.encodeBase64(bytes));
} catch (Exception e) {
return "";
}
}
public static FeatureVector decodeFeatureVector(String str) {
return decode(FeatureVector.class, str);
}
public static FeatureVector createNewFeatureVector() {
FeatureVector featureVector = new FeatureVector();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
Map<String, Set<String>> stringFeatures = new HashMap<>();
featureVector.setFloatFeatures(floatFeatures);
featureVector.setStringFeatures(stringFeatures);
return featureVector;
}
public static Example createNewExample() {
Example example = new Example();
example.setContext(createNewFeatureVector());
example.setExample(new ArrayList<FeatureVector>());
return example;
}
public static Example decodeExample(String str) {
return decode(Example.class, str);
}
public static ModelRecord decodeModel(String str) {
return decode(ModelRecord.class, str);
}
public static <T extends TBase> T decode(T base, String str) {
try {
byte[] bytes = Base64.decodeBase64(str.getBytes());
TDeserializer deserializer = new TDeserializer();
deserializer.deserialize(base, bytes);
} catch (Exception e) {
e.printStackTrace();
}
return base;
}
public static <T extends TBase> T decode(Class<T> clazz, String str) {
try {
return decode(clazz.newInstance(), str);
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return null;
}
public static KDTreeNode decodeKDTreeNode(String str) {
return decode(KDTreeNode.class, str);
}
public static <T extends TBase> List<T> readFromGzippedStream(Class<T> clazz, InputStream inputStream) {
try {
if (inputStream != null) {
GZIPInputStream gzipInputStream = new GZIPInputStream(inputStream);
BufferedReader reader = new BufferedReader(new InputStreamReader(gzipInputStream));
List<T> list = new ArrayList<>();
String line = reader.readLine();
while (line != null) {
T t = Util.decode(clazz, line);
if (t == null) {
assert (false);
return Collections.EMPTY_LIST;
}
list.add(t);
line = reader.readLine();
}
return list;
}
} catch (IOException e) {
e.printStackTrace();
}
return Collections.EMPTY_LIST;
}
public static void optionallyCreateStringFeatures(FeatureVector featureVector) {
if (featureVector.getStringFeatures() == null) {
Map<String, Set<String>> stringFeatures = new HashMap<>();
featureVector.setStringFeatures(stringFeatures);
}
}
public static void optionallyCreateFloatFeatures(FeatureVector featureVector) {
if (featureVector.getFloatFeatures() == null) {
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
featureVector.setFloatFeatures(floatFeatures);
}
}
public static void setStringFeature(
FeatureVector featureVector,
String family,
String value) {
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
if (stringFeatures == null) {
stringFeatures = new HashMap<>();
featureVector.setStringFeatures(stringFeatures);
}
Set<String> stringFamily = getOrCreateStringFeature(family, stringFeatures);
stringFamily.add(value);
}
public static Set<String> getOrCreateStringFeature(
String name,
Map<String, Set<String>> stringFeatures) {
Set<String> output = stringFeatures.get(name);
if (output == null) {
output = new HashSet<>();
stringFeatures.put(name, output);
}
return output;
}
public static Map<String, Double> getOrCreateFloatFeature(
String name,
Map<String, Map<String, Double>> floatFeatures) {
Map<String, Double> output = floatFeatures.get(name);
if (output == null) {
output = new HashMap<>();
floatFeatures.put(name, output);
}
return output;
}
public static Map<String, List<Double>> getOrCreateDenseFeatures(FeatureVector featureVector) {
if (featureVector.getDenseFeatures() == null) {
Map<String, List<Double>> dense = new HashMap<>();
featureVector.setDenseFeatures(dense);
}
return featureVector.getDenseFeatures();
}
public static void setDenseFeature(
FeatureVector featureVector,
String name,
List<Double> value) {
Map<String, List<Double>> denseFeatures = featureVector.getDenseFeatures();
if (denseFeatures == null) {
denseFeatures = new HashMap<>();
featureVector.setDenseFeatures(denseFeatures);
}
denseFeatures.put(name, value);
}
public static HashCode getHashCode(String family, String value) {
Hasher hasher = Hashing.murmur3_128().newHasher();
hasher.putBytes(family.getBytes());
hasher.putBytes(value.getBytes());
return hasher.hash();
}
public static <K, V extends Comparable<V>> Map.Entry<K, V>[] sortByValuesDesc(final Map<K, V> map) {
if (map == null || map.size() == 0) {
return null;
}
try {
@SuppressWarnings("unchecked")
Map.Entry<K, V>[] array = map.entrySet().toArray(new Map.Entry[map.size()]);
Arrays.sort(array, new Comparator<Map.Entry<K, V>>() {
public int compare(Map.Entry<K, V> e1, Map.Entry<K, V> e2) {
return e2.getValue().compareTo(e1.getValue());
}
});
return array;
} catch (Exception e) {
}
return null;
}
public static <K extends Comparable<K>, V> Map.Entry<K, V>[] sortByKeysAsc(final Map<K, V> map) {
if (map == null || map.size() == 0) {
return null;
}
try {
@SuppressWarnings("unchecked")
Map.Entry<K, V>[] array = map.entrySet().toArray(new Map.Entry[map.size()]);
Arrays.sort(array, new Comparator<Map.Entry<K, V>>() {
public int compare(Map.Entry<K, V> e1, Map.Entry<K, V> e2) {
return e1.getKey().compareTo(e1.getKey());
}
});
return array;
} catch (Exception e) {
}
return null;
}
public static double logBase2(double value) {
return Math.log(value) / LOG2;
}
public static Map<Integer, Double> prepareRankMap(List<Double> scores, List<Double> utilities) {
Map<Integer, Double> rankMap = new HashMap<Integer, Double>();
if (scores == null || utilities == null || scores.size() != utilities.size()) {
return rankMap;
}
Map<Integer, Double> scoresMap = new HashMap<>();
for (int i = 0; i < scores.size(); i++) {
scoresMap.put(i, scores.get(i));
}
Map.Entry<Integer, Double>[] kvs = sortByValuesDesc(scoresMap);
for (int j = 0; j < kvs.length; j++) {
double util = utilities.get(kvs[j].getKey());
rankMap.put(j, util);
}
return rankMap;
}
public static <K, V> Map<K, V> safeMap(Map<K, V> map) {
if (map == null) {
return Collections.EMPTY_MAP;
} else {
return map;
}
}
/**
* Flatten a feature vector from example to a nested stream(feature family, stream(feature name.
* feature value))
*/
public static Stream<? extends Map.Entry<String, Stream<? extends Map.Entry<String, Double>>>> flattenFeatureAsStream(FeatureVector featureVector) {
// reuse flatten with dropout = 0
return flattenFeatureWithDropoutAsStream(featureVector, 0.0, 0);
}
/**
* Flatten a feature vector from example to a nested map of feature family -> (feature -> value)
*/
public static Map<String, Map<String, Double>> flattenFeature(FeatureVector featureVector) {
return flattenFeatureStreamToMap(flattenFeatureAsStream(featureVector));
}
private static Random random = new Random();
/**
* Flatten a feature vector from example to a nested map of feature family -> (feature -> value)
* with dropout
*/
public static Map<String, Map<String, Double>> flattenFeatureWithDropout(FeatureVector featureVector, double dropout) {
long seed = random.nextLong();
return flattenFeatureStreamToMap(flattenFeatureWithDropoutAsStream(featureVector, dropout, seed));
}
/**
* Convert a flatten nested stream(feature family, stream(feature name. feature value)) to nested
* map of feature family -> (feature -> value)
*/
private static Map<String, Map<String, Double>> flattenFeatureStreamToMap(Stream<? extends Map.Entry<String, Stream<? extends Map.Entry<String, Double>>>> stream) {
Map<String, Map<String, Double>> outputFeatureMap = new HashMap<>();
stream.forEach(inputFamilyEntry -> {
String familyName = inputFamilyEntry.getKey();
Map<String, Double> outputFeatureFamily = outputFeatureMap.get(familyName);
if (outputFeatureFamily == null) {
outputFeatureFamily = new HashMap<>();
outputFeatureMap.put(familyName, outputFeatureFamily);
}
// NB: this is necessary due to stream semantic where variable inside forEach has to be final
final Map<String, Double> finalFeatures = outputFeatureFamily;
inputFamilyEntry.getValue().forEach(feature -> finalFeatures.put(feature.getKey(), feature.getValue()));
});
return outputFeatureMap;
}
/**
* Convert a feature vector from example to a nested stream(feature family, stream(feature name.
* feature value)) with dropout
*
* @apiNote Understand Stream can only be iterated once just like iterator, it is crucial to set a
* random seed if one wants to reproduce consistent dropout result.
*/
public static Stream<? extends Map.Entry<String, Stream<? extends Map.Entry<String, Double>>>> flattenFeatureWithDropoutAsStream(
FeatureVector featureVector, double dropout, long seed) {
// collect string features into a stream
Stream<? extends Map.Entry<String, Stream<? extends Map.Entry<String, Double>>>> stringFeatures = Stream.empty();
if (featureVector.stringFeatures != null) {
stringFeatures = featureVector.stringFeatures.entrySet().stream().map(entry -> {
Stream<? extends Map.Entry<String, Double>> values =
entry.getValue().stream()
.map(feature -> new HashMap.SimpleImmutableEntry<>(feature, 1.0));
return new HashMap.SimpleImmutableEntry<>(entry.getKey(), values);
});
}
// collect float features into a stream
Stream<? extends Map.Entry<String, Stream<? extends Map.Entry<String, Double>>>> floatFeatures = Stream.empty();
if (featureVector.floatFeatures != null) {
floatFeatures = featureVector.floatFeatures.entrySet().stream().map(entry ->
new HashMap.SimpleImmutableEntry<>(entry.getKey(), entry.getValue().entrySet().stream())
);
}
// concat string and float features and apply dropout if necessary
Stream<? extends Map.Entry<String, Stream<? extends Map.Entry<String, Double>>>> flatFeatures = Stream.concat(stringFeatures, floatFeatures);
if (dropout > 0) {
Random random = new Random(seed);
// dropout needs to be applied in the inner most stream
return flatFeatures.map(
entry -> new HashMap.SimpleImmutableEntry<>(entry.getKey(), entry.getValue().filter(x -> random.nextDouble() >= dropout))
);
} else {
return flatFeatures;
}
}
public static class DebugDiffRecordComparator implements Comparator<DebugScoreDiffRecord> {
@Override
public int compare(DebugScoreDiffRecord e1, DebugScoreDiffRecord e2) {
double v1 = Math.abs(e1.getFeatureWeightDiff());
double v2 = Math.abs(e2.getFeatureWeightDiff());
if (v1 > v2) {
return -1;
} else if (v1 < v2) {
return 1;
}
return 0;
}
}
private static Map<String, Map<String, Double>> debugScoreRecordListToMap(List<DebugScoreRecord> recordList) {
Map<String, Map<String, Double>> recordMap = new HashMap<>();
for (int i = 0; i < recordList.size(); i++) {
String key = recordList.get(i).featureFamily + '\t' + recordList.get(i).featureName;
Map<String, Double> record = new HashMap<>();
record.put("featureValue", recordList.get(i).featureValue);
record.put("featureWeight", recordList.get(i).featureWeight);
recordMap.put(key, record);
}
return recordMap;
}
public static List<DebugScoreDiffRecord> compareDebugRecords(List<DebugScoreRecord> record1,
List<DebugScoreRecord> record2) {
List<DebugScoreDiffRecord> debugDiffRecord = new ArrayList<>();
final String featureValue = "featureValue";
final String featureWeight = "featureWeight";
Set<String> keys = new HashSet();
Map<String, Map<String, Double>> recordMap1 = debugScoreRecordListToMap(record1);
Map<String, Map<String, Double>> recordMap2 = debugScoreRecordListToMap(record2);
keys.addAll(recordMap1.keySet());
keys.addAll(recordMap2.keySet());
for (String key : keys) {
DebugScoreDiffRecord diffRecord = new DebugScoreDiffRecord();
double fv1 = 0.0;
double fv2 = 0.0;
double fw1 = 0.0;
double fw2 = 0.0;
if (recordMap1.get(key) != null) {
fv1 = recordMap1.get(key).get(featureValue);
fw1 = recordMap1.get(key).get(featureWeight);
}
if (recordMap2.get(key) != null) {
fv2 = recordMap2.get(key).get(featureValue);
fw2 = recordMap2.get(key).get(featureWeight);
}
String[] fvString = key.split("\t");
diffRecord.setFeatureFamily(fvString[0]);
diffRecord.setFeatureName(fvString[1]);
diffRecord.setFeatureValue1(fv1);
diffRecord.setFeatureValue2(fv2);
diffRecord.setFeatureWeight1(fw1);
diffRecord.setFeatureWeight2(fw2);
diffRecord.setFeatureWeightDiff(fw1 - fw2);
debugDiffRecord.add(diffRecord);
}
Collections.sort(debugDiffRecord, new DebugDiffRecordComparator());
return debugDiffRecord;
}
public static <T> Set<T> getIntersection(Set<T> a, Set<T> b) {
if (a == null || b == null) {
return Collections.EMPTY_SET;
}
Set<T> small = (a.size() > b.size()) ? b : a;
Set<T> big = (a.size() > b.size()) ? a : b;
Set<T> intersection = new HashSet<T>(small);
intersection.retainAll(big);
return intersection;
}
public static float euclideanDistance(float[] x, List<Float> y) {
assert (x.length == y.size());
double sum = 0;
for (int i = 0; i < x.length; i++) {
final double dp = x[i] - y.get(i);
sum += dp * dp;
}
return (float) Math.sqrt(sum);
}
public static float euclideanDistance(List<Double> x, List<Float> y) {
assert (x.size() == y.size());
double sum = 0;
for (int i = 0; i < y.size(); i++) {
final double dp = x.get(i) - y.get(i);
sum += dp * dp;
}
return (float) Math.sqrt(sum);
}
}
| 7,171 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/util/KNearestNeighborsOptions.java | package com.airbnb.aerosolve.core.util;
import lombok.Getter;
import lombok.Setter;
public class KNearestNeighborsOptions {
public KNearestNeighborsOptions() {
numNearest = 5;
idKey = "";
outputKey = "";
featureKey = "";
}
@Getter @Setter
private int numNearest;
@Getter @Setter
public String idKey;
@Getter @Setter
public String outputKey;
@Getter @Setter
public String featureKey;
} | 7,172 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/util/MinKernelDenseFeatureDictionary.java | package com.airbnb.aerosolve.core.util;
import com.airbnb.aerosolve.core.FeatureVector;
import lombok.Setter;
import java.io.Serializable;
import java.util.*;
import java.util.AbstractMap.SimpleEntry;
import java.util.Map.Entry;
/**
* A class that maintains a dictionary for dense features and returns
* the responses of a new feature to each element in the dictionary.
*/
public class MinKernelDenseFeatureDictionary extends FeatureDictionary {
/**
/**
* Calculates the Min Kernel distance to each dictionary element.
* Returns the top K elements as a new sparse feature.
*/
@Override
public FeatureVector getKNearestNeighbors(
KNearestNeighborsOptions options,
FeatureVector featureVector) {
FeatureVector result = new FeatureVector();
Map<String, List<Double>> denseFeatures = featureVector.getDenseFeatures();
if (denseFeatures == null) {
return result;
}
PriorityQueue<SimpleEntry<String, Double>> pq = new PriorityQueue<>(
options.getNumNearest() + 1,
new EntryComparator());
String idKey = options.getIdKey();
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
String myId = featureVector.getStringFeatures()
.get(idKey).iterator().next();
for (FeatureVector supportVector : dictionaryList) {
Double minKernel = FeatureVectorUtil.featureVectorMinKernel(featureVector,
supportVector);
Set<String> idSet = supportVector.getStringFeatures().get(idKey);
String id = idSet.iterator().next();
if (id == myId) continue;
SimpleEntry<String, Double> entry = new SimpleEntry<String, Double>(id, minKernel);
pq.add(entry);
if (pq.size() > options.getNumNearest()) {
pq.poll();
}
}
HashMap<String, Double> newFeature = new HashMap<>();
while (pq.peek() != null) {
SimpleEntry<String, Double> entry = pq.poll();
newFeature.put(entry.getKey(), entry.getValue());
}
floatFeatures.put(options.getOutputKey(), newFeature);
result.setFloatFeatures(floatFeatures);
return result;
}
} | 7,173 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/util/Distance.java | package com.airbnb.aerosolve.core.util;
import com.airbnb.aerosolve.core.KDTreeNode;
// http://www.geodatasource.com/developers/java
public class Distance {
public static double miles(double lat1, double lon1, double lat2, double lon2) {
double theta = lon1 - lon2;
double degLat1 = deg2rad(lat1);
double degLat2 = deg2rad(lat2);
double dist = Math.sin(degLat1) * Math.sin(degLat2) +
Math.cos(degLat1) * Math.cos(degLat2) * Math.cos(deg2rad(theta));
dist = Math.acos(dist);
dist = rad2deg(dist);
return dist * 60 * 1.1515;
}
// assume kdtree node x is lat, and y is lng, return distance in miles between kdtree's max and min
public static double kdtreeDistanceInMiles(KDTreeNode node) {
return Distance.miles(node.getMaxX(), node.getMaxY(), node.getMinX(), node.getMinY());
}
public static double kilometers(double lat1, double lon1, double lat2, double lon2) {
return miles(lat1, lon1, lat2, lon2) * 1.609344;
}
public static double nauticalMiles(double lat1, double lon1, double lat2, double lon2) {
return miles(lat1, lon1, lat2, lon2) * 0.8684;
}
private static double deg2rad(double deg) {
return (deg * Math.PI / 180.0);
}
private static double rad2deg(double rad) {
return (rad * 180 / Math.PI);
}
}
| 7,174 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/util/SupportVector.java | package com.airbnb.aerosolve.core.util;
import lombok.Getter;
import lombok.Setter;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Random;
import com.airbnb.aerosolve.core.FunctionForm;
import com.airbnb.aerosolve.core.ModelRecord;
public class SupportVector implements Serializable {
// Dense support vector value.
@Getter @Setter
FloatVector floatVector;
// What kind of kernel e.g. RBF
@Getter @Setter
FunctionForm form;
// Kernel parameter .. for:
// RBF : response = exp(- scale * || sv - other || ^ 2)
@Getter @Setter
float scale;
// Weight of the kernel
@Getter @Setter
float weight;
public SupportVector(FloatVector fv, FunctionForm f, float s, float wt) {
floatVector = fv;
form = f;
scale = s;
weight = wt;
}
public SupportVector(ModelRecord rec) {
scale = (float) rec.scale;
form = rec.getFunctionForm();
weight = (float) rec.getFeatureWeight();
int size = rec.weightVector.size();
floatVector = new FloatVector(size);
for (int i = 0; i < size; i++) {
floatVector.getValues()[i] = rec.weightVector.get(i).floatValue();
}
}
public ModelRecord toModelRecord() {
ModelRecord rec = new ModelRecord();
rec.setScale(scale);
rec.setFunctionForm(form);
ArrayList<Double> weightVector = new ArrayList<>();
for (int i = 0; i < floatVector.getValues().length; i++) {
weightVector.add((double) floatVector.getValues()[i]);
}
rec.setWeightVector(weightVector);
rec.setFeatureWeight(weight);
return rec;
}
// Evaluates the support vector with the other.
public float evaluateUnweighted(FloatVector other) {
float result = 0.0f;
switch (form) {
case RADIAL_BASIS_FUNCTION: {
result = (float) Math.exp(-scale * floatVector.l2Distance2(other));
break;
}
case ARC_COSINE: {
float top = floatVector.dot(other);
float bot = floatVector.dot(floatVector) * other.dot(other);
if (bot < 1e-6f) {
bot = 1e-6f;
}
double cos_theta = Math.max(0.0, Math.min(1.0, top / Math.sqrt(bot)));
double theta = Math.acos(cos_theta);
result = (float) (1.0 - theta / Math.PI);
break;
}
}
return result;
}
// Evaluates the weighted support vector
public float evaluate(FloatVector other) {
return weight * evaluateUnweighted(other);
}
} | 7,175 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/util/Weibull.java | package com.airbnb.aerosolve.core.util;
import lombok.experimental.Builder;
import lombok.extern.slf4j.Slf4j;
/*
weibull(x) = exp(a*(x)^k + b)
default max x is Double.MAX_VALUE
*/
@Slf4j @Builder public class Weibull {
final private double k, a, b, maxX;
public WeibullBuilder defaultBuilder() {
return Weibull.builder().maxX(Double.MAX_VALUE);
}
public double getWeibull(double x) {
return Math.exp(a * Math.pow(x, k) + b);
}
/*
weibull(x) = exp(a*(x)^k + b)
given value of weibull(x), return x
*/
public double getXWithOutput(double output) {
// Below are the logic to compute the x:
// val t = (Math.log(p) - b) / a
// if (t > 0) ratio = math.min(math.pow(t, 1.0 / k), 2)
// else x = 0.0
if (Math.abs(a) < 1e-10) {
if (b > Math.log(output)) {
return maxX;
} else {
return 0.0;
}
}
// a is not too small.
double t = (Math.log(output) - b) / a;
log.debug("k = {}, a = {}, b = {}, t = {}", k, a, b, t);
if (t > 0) {
return Math.min(Math.pow(t, 1.0/k), maxX);
} else {
return 0.0;
}
}
}
| 7,176 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/util/ReinforcementLearning.java | package com.airbnb.aerosolve.core.util;
/**
* Utilities for reinforcement learning
*/
import com.airbnb.aerosolve.core.models.AbstractModel;
import com.airbnb.aerosolve.core.FeatureVector;
import com.google.common.hash.HashCode;
import com.google.common.hash.Hasher;
import com.google.common.hash.Hashing;
import org.apache.commons.codec.binary.Base64;
import org.apache.thrift.TDeserializer;
import org.apache.thrift.TSerializer;
import org.apache.thrift.TBase;
import java.io.Serializable;
import java.util.*;
public class ReinforcementLearning implements Serializable {
// Updates a model using SARSA
// https://en.wikipedia.org/wiki/State-Action-Reward-State-Action
// If the nextState is terminal, pass in null
public static void updateSARSA(AbstractModel model,
FeatureVector stateAction,
float reward,
FeatureVector nextStateAction,
float learningRate,
float discountRate) {
Map<String, Map<String, Double>> flatSA = Util.flattenFeature(stateAction);
float nextQ = 0.0f;
if (nextStateAction != null) {
nextQ = model.scoreItem(nextStateAction);
}
float currentQ = model.scoreItem(stateAction);
float expectedQ = reward + discountRate * nextQ;
float grad = currentQ - expectedQ;
model.onlineUpdate(grad, learningRate, flatSA);
}
// Picks a random action with probability epsilon.
public static int epsilonGreedyPolicy(AbstractModel model, ArrayList<FeatureVector> stateAction, float epsilon, Random rnd) {
if (rnd.nextFloat() <= epsilon) {
return rnd.nextInt(stateAction.size());
}
int bestAction = 0;
float bestScore = model.scoreItem(stateAction.get(0));
for (int i = 1; i < stateAction.size(); i++) {
FeatureVector sa = stateAction.get(i);
float score = model.scoreItem(sa);
if (score > bestScore) {
bestAction = i;
bestScore = score;
}
}
return bestAction;
}
// Uses softmax to determine the action.
// As temperature approaches zero the action approaches the greedy action.
public static int softmaxPolicy(AbstractModel model, ArrayList<FeatureVector> stateAction, float temperature, Random rnd) {
int count = stateAction.size();
float[] scores = new float[count];
float[] cumScores = new float[count];
float maxVal = -1e10f;
for (int i = 0; i < count; i++) {
FeatureVector sa = stateAction.get(i);
scores[i] = model.scoreItem(sa);
maxVal = Math.max(maxVal, scores[i]);
}
for (int i = 0; i < count; i ++) {
scores[i] = (float) Math.exp((scores[i] - maxVal) / temperature);
cumScores[i] = scores[i];
if (i > 0) {
cumScores[i] += cumScores[i - 1];
}
}
float threshold = rnd.nextFloat() * cumScores[count - 1];
for (int i = 0; i < count; i++) {
if (threshold <= cumScores[i]) {
return i;
}
}
return 0;
}
} | 7,177 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/util/TransformUtil.java | package com.airbnb.aerosolve.core.util;
/**
* Utility class for methods that are commonly used by transforms and should be shared.
* TODO: go through all transforms and add all common methods here.
* TODO: go through Util class and add all transform related / exclusive methods here.
*/
public class TransformUtil {
public static Double quantize(double val, double delta) {
Double mult = val / delta;
return delta * mult.intValue();
}
}
| 7,178 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/util/DateUtil.java | package com.airbnb.aerosolve.core.util;
import lombok.extern.slf4j.Slf4j;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.ZoneId;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;
@Slf4j
public class DateUtil {
public static <R> Map<String, R> applyForDateRange(String startDate, String endDate, Function<String, R> f) {
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
Map<String, R> map = new HashMap<>();
try {
Date startD = formatter.parse(startDate);
Date endD = formatter.parse(endDate);
LocalDate start = startD.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
LocalDate end = endD.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
for (LocalDate date = start; date.isBefore(end); date = date.plusDays(1)) {
String d = date.toString();
R r = f.apply(d);
if (r != null) {
map.put(d, r);
}
}
} catch (ParseException e) {
log.error("wrong date format? {} {}", startDate, endDate);
}
return map;
}
}
| 7,179 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/util/LocalitySensitiveHashSparseFeatureDictionary.java | package com.airbnb.aerosolve.core.util;
import com.airbnb.aerosolve.core.FeatureVector;
import lombok.Setter;
import java.io.Serializable;
import java.util.*;
import java.util.AbstractMap.SimpleEntry;
import java.util.Map.Entry;
/**
* A class that maintains a dictionary for sparse features and returns
* the responses of a new feature to each element in the dictionary.
*/
public class LocalitySensitiveHashSparseFeatureDictionary extends FeatureDictionary {
private Map<String, Set<Integer>> LSH;
private boolean haveLSH;
public LocalitySensitiveHashSparseFeatureDictionary() {
haveLSH = false;
}
private int similarity(FeatureVector f1,
FeatureVector f2,
String featureKey) {
Set<String> s1 = f1.getStringFeatures().get(featureKey);
if (s1 == null) {
return 0;
}
Set<String> s2 = f2.getStringFeatures().get(featureKey);
if (s2 == null) {
return 0;
}
Set<String> intersection = new HashSet<String>(s1);
intersection.retainAll(s2);
return intersection.size();
}
// Builds the hash table lookup for the LSH.
private void buildHashTable(String featureKey) {
LSH = new HashMap<>();
assert(dictionaryList instanceof ArrayList);
int size = dictionaryList.size();
for (int i = 0; i < size; i++) {
FeatureVector featureVector = dictionaryList.get(i);
Set<String> keys = featureVector.getStringFeatures().get(featureKey);
if (keys == null) {
continue;
}
for (String key : keys) {
Set<Integer> row = LSH.get(key);
if (row == null) {
row = new HashSet<>();
LSH.put(key, row);
}
row.add(i);
}
}
}
// Returns all the candidates with a hash overlap.
private Set<Integer> getCandidates(Set<String> keys) {
Set<Integer> result = new HashSet<>();
for (String key : keys) {
Set<Integer> row = LSH.get(key);
if (row != null) {
result.addAll(row);
}
}
return result;
}
@Override
public FeatureVector getKNearestNeighbors(
KNearestNeighborsOptions options,
FeatureVector featureVector) {
FeatureVector result = new FeatureVector();
Map<String, Set<String>> stringFeatures = featureVector.getStringFeatures();
if (stringFeatures == null) {
return result;
}
String featureKey = options.getFeatureKey();
Set<String> keys = stringFeatures.get(featureKey);
if (keys == null) {
return result;
}
if (!haveLSH) {
buildHashTable(featureKey);
}
String idKey = options.getIdKey();
PriorityQueue<SimpleEntry<String, Double>> pq = new PriorityQueue<>(
options.getNumNearest() + 1,
new EntryComparator());
Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
String myId = featureVector.getStringFeatures()
.get(idKey).iterator().next();
Set<Integer> candidates = getCandidates(keys);
for (Integer candidate : candidates) {
FeatureVector supportVector = dictionaryList.get(candidate);
double sim = similarity(featureVector,
supportVector,
featureKey);
Set<String> idSet = supportVector.getStringFeatures().get(idKey);
String id = idSet.iterator().next();
if (id == myId) {
continue;
}
SimpleEntry<String, Double> entry = new SimpleEntry<String, Double>(id, sim);
pq.add(entry);
if (pq.size() > options.getNumNearest()) {
pq.poll();
}
}
HashMap<String, Double> newFeature = new HashMap<>();
while (pq.peek() != null) {
SimpleEntry<String, Double> entry = pq.poll();
newFeature.put(entry.getKey(), entry.getValue());
}
floatFeatures.put(options.getOutputKey(), newFeature);
result.setFloatFeatures(floatFeatures);
return result;
}
} | 7,180 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/util/Debug.java | package com.airbnb.aerosolve.core.util;
import com.airbnb.aerosolve.core.Example;
import com.airbnb.aerosolve.core.FeatureVector;
import lombok.extern.slf4j.Slf4j;
import org.apache.thrift.TDeserializer;
import org.apache.thrift.TSerializer;
import org.apache.thrift.protocol.TBinaryProtocol;
import java.io.FileOutputStream;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Map;
import java.util.Set;
@Slf4j
public class Debug {
public static int printDiff(FeatureVector a, FeatureVector b) {
final Map<String, Set<String>> stringFeaturesA = a.getStringFeatures();
final Map<String, Set<String>> stringFeaturesB = b.getStringFeatures();
int diff = printDiff(stringFeaturesA, stringFeaturesB);
final Map<String, Map<String, Double>> floatFeaturesA = a.getFloatFeatures();
final Map<String, Map<String, Double>> floatFeaturesB = b.getFloatFeatures();
diff += printFloatDiff(floatFeaturesA, floatFeaturesB);
return diff;
}
private static int printFloatDiff(Map<String, Map<String, Double>> a,
Map<String, Map<String, Double>> b) {
int diff = 0;
for (Map.Entry<String, Map<String, Double>> entry : a.entrySet()) {
String key = entry.getKey();
Map<String, Double> bSet = b.get(key);
if (bSet == null) {
log.info("b miss float family {}", key);
diff++;
} else {
diff += printMapDiff(entry.getValue(), bSet);
}
}
for (Map.Entry<String, Map<String, Double>> entry : b.entrySet()) {
String key = entry.getKey();
Map<String, Double> bSet = a.get(key);
if (bSet == null) {
log.info("a miss float family {}", key);
diff++;
}
}
return diff;
}
private static int printMapDiff(Map<String, Double> a, Map<String, Double> b) {
int diff = 0;
for (Map.Entry<String, Double> entry : a.entrySet()) {
String key = entry.getKey();
Double bValue = b.get(key);
if (bValue == null) {
log.info("b miss feature {} {}", key, entry.getValue());
diff++;
} else {
if (Math.abs(bValue- entry.getValue()) > 0.01) {
log.info("feature {} a: {}, b: {}", key, entry.getValue(), bValue);
diff++;
}
}
}
for (Map.Entry<String, Double> entry : b.entrySet()) {
String key = entry.getKey();
Double bValue = a.get(key);
if (bValue == null) {
log.info("a miss feature {} {}", key, entry.getValue());
diff++;
}
}
return diff;
}
public static int printDiff(Map<String, Set<String>> a, Map<String, Set<String>> b) {
int diff = 0;
for (Map.Entry<String, Set<String>> entry : a.entrySet()) {
String key = entry.getKey();
Set<String> bSet = b.get(key);
if (bSet == null) {
log.info("b miss string family {}", key);
diff++;
} else {
diff += printDiff(entry.getValue(), bSet);
}
}
for (Map.Entry<String, Set<String>> entry : b.entrySet()) {
String key = entry.getKey();
Set<String> bSet = a.get(key);
if (bSet == null) {
log.info("a miss string family {}", key);
diff++;
}
}
return diff;
}
private static int printDiff(Set<String> a, Set<String> b) {
int diff = 0;
for(String s : a) {
if (!b.contains(s)) {
log.info("b missing {}", s);
diff++;
}
}
for(String s : b) {
if (!a.contains(s)) {
log.info("a missing {}", s);
diff++;
}
}
return diff;
}
/*
loadExampleFromResource read example from resources folder, i.e. test/resources
use it on unit test to load example from disk
*/
public static Example loadExampleFromResource(String name) {
URL url = Debug.class.getResource("/" + name);
try {
Path path = Paths.get(url.toURI());
byte[] bytes = Files.readAllBytes(path);
TDeserializer deserializer = new TDeserializer(new TBinaryProtocol.Factory());
Example example = new Example();
deserializer.deserialize(example, bytes);
return example;
} catch (Exception e) {
e.printStackTrace();
}
assert(false);
return null;
}
// Save example to path
// If you hit permission error, touch and chmod the file
public static void saveExample(Example example, String path) {
TSerializer serializer = new TSerializer(new TBinaryProtocol.Factory());
try {
byte[] buf = serializer.serialize(example);
FileOutputStream fos = new FileOutputStream(path);
fos.write(buf);
fos.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
| 7,181 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/util/FeatureVectorUtil.java | package com.airbnb.aerosolve.core.util;
import com.airbnb.aerosolve.core.FeatureVector;
import java.util.List;
import java.util.Set;
public class FeatureVectorUtil {
/**
* Computes the min kernel for one feature family.
* @param featureKey - name of feature e.g. "rgb"
* @param a - first feature vector
* @param b - second feature vector
* @return - sum(min(a(i), b(i))
*/
public static double featureMinKernel(String featureKey,
FeatureVector a,
FeatureVector b) {
double sum = 0.0;
if (a.getDenseFeatures() == null || b.getDenseFeatures() == null) {
return 0.0;
}
List<Double> aFeat = a.getDenseFeatures().get(featureKey);
List<Double> bFeat = b.getDenseFeatures().get(featureKey);
if (aFeat == null || bFeat == null) {
return 0.0;
}
int count = aFeat.size();
for (int i = 0; i < count; i++) {
if (aFeat.get(i) < bFeat.get(i)) {
sum += aFeat.get(i);
} else {
sum += bFeat.get(i);
}
}
return sum;
}
/**
*
* @param a - a feature vector
* @param b - another feature vector
* @return the min kernel between both feature vectors.
*/
public static double featureVectorMinKernel(FeatureVector a,
FeatureVector b) {
double sum = 0.0;
if (a.getDenseFeatures() == null) {
return 0.0;
}
Set<String> keys = a.getDenseFeatures().keySet();
for (String key : keys) {
sum += featureMinKernel(key, a, b);
}
return sum;
}
} | 7,182 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/util/StringDictionary.java | package com.airbnb.aerosolve.core.util;
import com.airbnb.aerosolve.core.FeatureVector;
import com.airbnb.aerosolve.core.DictionaryEntry;
import com.airbnb.aerosolve.core.DictionaryRecord;
import lombok.Getter;
import lombok.Setter;
import java.io.Serializable;
import java.util.*;
import java.util.AbstractMap.SimpleEntry;
import java.util.Map.Entry;
/**
* A class that maps strings to indices. It can be used to map sparse
* features (both sparse string and sparse float) into dense float vectors.
*/
public class StringDictionary implements Serializable {
/**
* The dictionary to maintain
*/
@Getter
protected DictionaryRecord dictionary;
public StringDictionary() {
dictionary = new DictionaryRecord();
dictionary.setDictionary(new HashMap<String, Map<String, DictionaryEntry>>());
dictionary.setEntryCount(0);
}
public StringDictionary(DictionaryRecord dict) {
dictionary = dict;
}
// Returns the dictionary entry, null if not present
public DictionaryEntry getEntry(String family, String feature) {
Map<String, DictionaryEntry> familyMap = dictionary.dictionary.get(family);
if (familyMap == null) {
return null;
}
return familyMap.get(feature);
}
// Returns -1 if key exists, the index it was inserted if successful.
public int possiblyAdd(String family, String feature, double mean, double scale) {
Map<String, DictionaryEntry> familyMap = dictionary.dictionary.get(family);
if (familyMap == null) {
familyMap = new HashMap<>();
dictionary.dictionary.put(family, familyMap);
}
if (familyMap.containsKey(feature)) return -1;
DictionaryEntry entry = new DictionaryEntry();
int currIdx = dictionary.getEntryCount();
entry.setIndex(currIdx);
entry.setMean(mean);
entry.setScale(scale);
dictionary.setEntryCount(currIdx + 1);
familyMap.put(feature, entry);
return currIdx;
}
public FloatVector makeVectorFromSparseFloats(Map<String, Map<String, Double>> sparseFloats) {
FloatVector vec = new FloatVector(dictionary.getEntryCount());
for (Map.Entry<String, Map<String, Double>> kv : sparseFloats.entrySet()) {
for (Map.Entry<String, Double> feat : kv.getValue().entrySet()) {
DictionaryEntry entry = getEntry(kv.getKey(), feat.getKey());
if (entry != null) {
vec.values[entry.index] = (float) entry.scale * (feat.getValue().floatValue() - (float) entry.mean);
}
}
}
return vec;
}
} | 7,183 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/util/FloatVector.java | package com.airbnb.aerosolve.core.util;
import lombok.Getter;
import lombok.Setter;
import java.io.Serializable;
import java.util.Random;
// TODO change to FloatVector<T>
public class FloatVector implements Serializable {
private static final Random rnd = new java.util.Random();
public static class MinMaxResult {
public int minIndex;
public int maxIndex;
public float minValue;
public float maxValue;
}
@Getter @Setter
public float values[];
public FloatVector() {
}
public FloatVector(int num) {
setZero(num);
}
public FloatVector(float val[]) {
values = val;
}
public void set(int i, float val) {
values[i] = val;
}
public float get(int i) {
return values[i];
}
public static FloatVector getGaussianVector(int num) {
float[] init = new float[num];
double mult = 1.0 / Math.sqrt(num);
for (int i = 0; i < num; i++) {
init[i] = (float) (rnd.nextGaussian() * mult);
}
return new FloatVector(init);
}
public static FloatVector getGaussianVector(int num, float std) {
float[] init = new float[num];
for (int i = 0; i < num; i++) {
init[i] = (float) (rnd.nextGaussian() * std);
}
return new FloatVector(init);
}
public static FloatVector getUniformVector(int num) {
// uniformly sample from -1/sqrt(num) to +1/sqrt(num)
float[] init = new float[num];
double mult = 1.0 / Math.sqrt(num);
for (int i = 0; i < num; i++) {
init[i] = (float) (rnd.nextFloat() * mult * 2 - mult);
}
return new FloatVector(init);
}
public void setZero(int num) {
values = new float[num];
}
public void setConstant(float c) {
for (int i = 0; i < values.length; i++) {
values[i] = c;
}
}
public void setRandom(int num, float scale) {
setZero(num);
for (int i = 0; i < values.length; i++) {
values[i] = (2.0f * rnd.nextFloat() - 1.0f) * scale;
}
}
public float dot(FloatVector other) {
assert(values.length == other.values.length);
float sum = 0;
for (int i = 0; i < values.length; i++) {
sum += values[i] * other.values[i];
}
return sum;
}
public float l2Norm() {
float sum = 0;
for (int i = 0; i < values.length; i++) {
sum += values[i] * values[i];
}
return (float) Math.sqrt(sum);
}
public void scale(float scale) {
for (int i = 0; i < values.length; i++) {
values[i] *= scale;
}
}
public void capNorm(float maxNorm) {
float norm = this.l2Norm();
if (norm > maxNorm) {
this.scale(maxNorm / norm);
}
}
public void sigmoid() {
for (int i = 0; i < values.length; i++) {
// this is to prevent overflow
values[i] = Math.max(values[i], -20);
values[i] = 1.0f /(1.0f + (float) Math.exp(-values[i]));
}
}
public void tanh() {
for (int i = 0; i < values.length; i++) {
values[i] = (float) Math.tanh(values[i]);
}
}
public int length() {
return values.length;
}
// Squared euclidean distance
public float l2Distance2(FloatVector other) {
assert(values.length == other.values.length);
float sum = 0;
for (int i = 0; i < values.length; i++) {
float diff = values[i] - other.values[i];
sum += diff * diff;
}
return sum;
}
public void add(FloatVector other) {
assert(values.length == other.values.length);
for (int i = 0; i < values.length; i++) {
values[i] += other.values[i];
}
}
public void multiplyAdd(float w, FloatVector other) {
assert(values.length == other.values.length);
for (int i = 0; i < values.length; i++) {
values[i] += w * other.values[i];
}
}
public void rectify() {
for (int i = 0; i < values.length; i++) {
if (values[i] < 0) {
values[i] = 0.0f;
}
}
}
public void softmax() {
float maxVal = values[0];
for (int i = 1; i < values.length; i++) {
maxVal = Math.max(maxVal, values[i]);
}
float sum = 0.0f;
for (int i = 0; i < values.length; i++) {
values[i] = (float) Math.exp(values[i] - maxVal);
sum += values[i];
}
if (sum <= 1e-10f) {
sum = 1e-10f;
}
for (int i = 0; i < values.length; i++) {
values[i] /= sum;
}
}
public String toString() {
return java.util.Arrays.toString(values);
}
public static FloatVector Hadamard(FloatVector a, FloatVector b) {
assert(a.values.length == b.values.length);
FloatVector out = new FloatVector(a.values.length);
for (int i = 0; i < a.values.length; i++) {
out.values[i] = a.values[i] * b.values[i];
}
return out;
}
// Returns the indices and values of the min/max of the vector.
// The first half of the vector stores the "min" hidden layer
// and the second half of the vector stores the "max".
// In both cases the largest value is used as a selector, the name
// is just used to keep the positive and negative maxout planes
// disjoint but for memory efficiency stored in the same vector.
public MinMaxResult getMinMaxResult() {
MinMaxResult result = new MinMaxResult();
int mid = values.length / 2;
result.minIndex = 0;
result.minValue = values[0];
for (int i = 1; i < mid; i++) {
float curr = values[i];
if (curr > result.minValue) {
result.minValue = curr;
result.minIndex = i;
}
}
result.maxIndex = 1;
result.maxValue = values[mid];
for (int i = mid + 1; i < values.length; i++) {
float curr = values[i];
if (curr > result.maxValue) {
result.maxValue = curr;
result.maxIndex = i;
}
}
return result;
}
} | 7,184 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/images/ImageFeatureInterface.java | package com.airbnb.aerosolve.core.images;
import java.awt.image.BufferedImage;
interface ImageFeatureInterface {
// Returns the size of the feature.
int featureSize();
// Pre-computes features in the image
void analyze(BufferedImage image);
// Extracts features from an image inside the window
// [sx, sy] to (ex, ey)
float[] extractFeature(int sx, int sy, int ex, int ey);
}
| 7,185 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/images/LBPFeature.java | package com.airbnb.aerosolve.core.images;
import java.awt.image.BufferedImage;
import java.lang.Override;
/*
Creates a histogram of local binary patterns
http://www.mediateam.oulu.fi/publications/pdf/94.p
http://en.wikipedia.org/wiki/Local_binary_patterns
*/
public class LBPFeature extends ImageFeature {
private static final int kNumBins = 256;
private byte[][] lbpBin = null;
private BufferedImage imgRef = null;
@Override public String featureName() {
return "lbp";
}
// There are 9 orientation bins. This was determined
// to be the optimal bin size by the Dalal and Triggs paper.
@Override public int featureSize() {
return kNumBins;
}
@Override
public void analyze(BufferedImage image) {
imgRef = image;
int width = image.getWidth();
int height = image.getHeight();
int[][] lum = new int[width][height];
// Compute sum of all channels per pixel
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
int pixel = image.getRGB(x, y);
for (int i = 0; i < 3; i++) {
lum[x][y] += pixel & 0xff;
pixel = pixel >> 8;
}
// Average then divide by 4. The /4 is so that
// we ignore smaller luminance changes of 4 levels or less.
lum[x][y] /= 3 * 4;
}
}
lbpBin = new byte[width][height];
for (int y = 1; y < height - 1; y++) {
for (int x = 1; x < width - 1; x++) {
lbpBin[x][y] |= (lum[x - 1][y - 1] > lum[x][y] ? 1 : 0) << 7;
lbpBin[x][y] |= (lum[x + 0][y - 1] > lum[x][y] ? 1 : 0) << 6;
lbpBin[x][y] |= (lum[x + 1][y - 1] > lum[x][y] ? 1 : 0) << 5;
lbpBin[x][y] |= (lum[x - 1][y + 0] > lum[x][y] ? 1 : 0) << 4;
lbpBin[x][y] |= (lum[x + 1][y + 0] > lum[x][y] ? 1 : 0) << 3;
lbpBin[x][y] |= (lum[x - 1][y + 1] > lum[x][y] ? 1 : 0) << 2;
lbpBin[x][y] |= (lum[x + 0][y + 1] > lum[x][y] ? 1 : 0) << 1;
lbpBin[x][y] |= (lum[x + 1][y + 1] > lum[x][y] ? 1 : 0);
}
}
}
@Override
public float[] extractFeature(int sx, int sy, int ex, int ey) {
float[] feature = new float[featureSize()];
if (sx >= ex || sy >= ey ||
ex > imgRef.getWidth() || ey > imgRef.getHeight()) {
return feature;
}
float sum = 0;
for (int y = sy; y < ey; y++) {
for (int x = sx; x < ex; x++) {
for (int i = 0; i < kNumBins; i++) {
short bin = lbpBin[x][y];
if (bin < 0) {
// Since java bytes are signed, fix the negative
// bytes by adding 128 twice.
bin += 256;
}
feature[bin] += 1.0;
sum += 1.0;
}
}
}
if (sum > 0) {
float scale = 1.0f / sum;
for (int i = 0; i < featureSize(); i++) {
feature[i] *= scale;
}
}
return feature;
}
}
| 7,186 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/images/ImageFeature.java | package com.airbnb.aerosolve.core.images;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.List;
public abstract class ImageFeature implements ImageFeatureInterface {
public abstract String featureName();
public abstract int featureSize();
public abstract void analyze(BufferedImage image);
public abstract float[] extractFeature(int sx, int sy, int ex, int ey);
/* The following functions compute the Spatial Pyramid Match Kernel
for the feature. This is a weighted sum of different partitions of an image.
The weights for levels 0, 1, 2 are [0.25, 0.25, 0.5] respectively
so higher weights are given to finer subdivisions following the
formula given in the paper.
See http://www-cvr.ai.uiuc.edu/ponce_grp/publication/paper/cvpr06b.pdf
*/
public void addAndScale(List<Float> featureList,
float[] featureInput, int count, float scale) {
for (int i = 0; i < count; i++) {
featureList.add(scale * featureInput[i]);
}
}
public void SPMKHelper(List<Float> featureList,
int sx, int sy, int ex, int ey,
int splits, float scale) {
if (splits <= 1) {
float tmp[] = extractFeature(sx, sy, ex, ey);
addAndScale(featureList, tmp, featureSize(), scale);
return;
}
int dx = (ex - sx) / splits;
int dy = (ey - sy) / splits;
for (int i = 0; i < splits; i++) {
for (int j = 0; j < splits; j++) {
int x = sx + i * dx;
int y = sy + j * dy;
float tmp[] = extractFeature(x, y, x + dx, y + dy);
addAndScale(featureList, tmp, featureSize(), scale);
}
}
}
public List<Float> extractFeatureSPMK(BufferedImage image) {
List<Float> feature = new ArrayList<>();
final int kPad = 3;
int width = image.getWidth() - kPad;
int height = image.getHeight() - kPad;
analyze(image);
SPMKHelper(feature, kPad, kPad, width, height, 1, 0.25f);
SPMKHelper(feature, kPad, kPad, width, height, 2, 0.25f);
SPMKHelper(feature, kPad, kPad, width, height, 4, 0.5f);
return feature;
}
} | 7,187 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/images/HOGFeature.java | package com.airbnb.aerosolve.core.images;
import java.awt.image.BufferedImage;
import java.lang.Override;
import java.lang.Math;
/*
Creates a histogram of oriented gradients.
http://en.wikipedia.org/wiki/Histogram_of_oriented_gradients
*/
public class HOGFeature extends ImageFeature {
private static final int kNumBins = 9;
// The histogram of oriented gradients.
// Split into two parts : gradient magnitude and bin.
private float[][] gradientMagnitude = null;
private byte[][] gradientBin = null;
private BufferedImage imgRef = null;
// Lookup table so we do not have to compute the atan
// millions of times.
private static byte[][] atanTable = computeAtanTable();
private static byte[][] computeAtanTable() {
// The possible values of dx and dy range from
// -255 to 255. So there are 511 values each.
// To prevent divisions by zero
final float kEpsilon = 1e-3f;
byte[][] atanTable = new byte[511][511];
for (int y = 0; y < 511; y++) {
for (int x = 0; x < 511; x++) {
float dx = x - 255;
float dy = y - 255;
if (x == 0) {
dx = kEpsilon;
}
float grad = dy / dx;
Double theta = Math.atan(grad);
theta = kNumBins * (0.5 + theta / Math.PI);
Integer bin = theta.intValue();
if (bin < 0) {
bin = 0;
}
if (bin >= kNumBins) {
bin = kNumBins - 1;
}
atanTable[x][y] = bin.byteValue();
}
}
return atanTable;
}
@Override public String featureName() {
return "hog";
}
// There are 9 orientation bins. This was determined
// to be the optimal bin size by the Dalal and Triggs paper.
@Override public int featureSize() {
return kNumBins;
}
@Override
public void analyze(BufferedImage image) {
imgRef = image;
int width = image.getWidth();
int height = image.getHeight();
gradientMagnitude = new float[width][height];
gradientBin = new byte[width][height];
int[][] lum = new int[width][height];
// Compute sum of all channels per pixel
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
int pixel = image.getRGB(x, y);
for (int i = 0; i < 3; i++) {
lum[x][y] += pixel & 0xff;
pixel = pixel >> 8;
}
lum[x][y] /= 3;
}
}
for (int y = 1; y < height - 1; y++) {
for (int x = 1; x < width - 1; x++) {
int dx = lum[x + 1][y] - lum[x - 1][y];
int dy = lum[x][y + 1] - lum[x][y - 1];
byte bin = atanTable[dx + 255][dy + 255];
Double mag = Math.sqrt(dx * dx + dy * dy);
gradientMagnitude[x][y] = mag.floatValue();
gradientBin[x][y] = bin;
}
}
}
@Override
public float[] extractFeature(int sx, int sy, int ex, int ey) {
float[] feature = new float[featureSize()];
if (sx >= ex || sy >= ey ||
ex > imgRef.getWidth() || ey > imgRef.getHeight()) {
return feature;
}
float sum = 0;
for (int y = sy; y < ey; y++) {
for (int x = sx; x < ex; x++) {
for (int i = 0; i < kNumBins; i++) {
byte bin = gradientBin[x][y];
float mag = gradientMagnitude[x][y];
feature[bin] += mag;
sum += mag;
}
}
}
if (sum > 0) {
float scale = 1.0f / sum;
for (int i = 0; i < featureSize(); i++) {
feature[i] *= scale;
}
}
return feature;
}
}
| 7,188 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/images/HSVFeature.java | package com.airbnb.aerosolve.core.images;
import java.awt.image.BufferedImage;
import java.awt.Color;
import java.lang.Override;
import java.lang.Math;
/*
Creates a histogram of Hue, saturation, value.
This is a different color space than rgb and focuses more on color.
*/
public class HSVFeature extends ImageFeature {
private int[][] hsv = null;
private BufferedImage imgRef = null;
// Number of buckets for hue and saturation.
private final int kSatBuckets = 4;
private final int kHueBuckets = 16;
// The cutoff for brightness.
private static float kMinBrightness = 0.25f;
@Override public String featureName() {
return "hsv";
}
// There are kBuckets ^ 2 bins for hue and saturation and one more for "dark".
@Override public int featureSize() {
return 1 + kSatBuckets * kHueBuckets;
}
@Override
public void analyze(BufferedImage image) {
imgRef = image;
int width = image.getWidth();
int height = image.getHeight();
hsv = new int[width][height];
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
int pixel = image.getRGB(x, y);
int r = (pixel >> 16) & 0xff;
int g = (pixel >> 8) & 0xff;
int b = pixel & 0xff;
float[] hsb = Color.RGBtoHSB(r, g, b, null);
int token = 0; // Dark.
// We really only care about the color so discard any
// dark color less than 25% brightness.
if (hsb[2] > kMinBrightness) {
int hue = Math.round((kHueBuckets - 1) * hsb[0]);
int sat = Math.round((kSatBuckets - 1) * hsb[1]);
token = 1 + kHueBuckets * sat + hue;
}
hsv[x][y] = token;
}
}
}
@Override
public float[] extractFeature(int sx, int sy, int ex, int ey) {
float[] feature = new float[featureSize()];
if (sx >= ex || sy >= ey ||
ex > imgRef.getWidth() || ey > imgRef.getHeight()) {
return feature;
}
int count = 0;
for (int y = sy; y < ey; y++) {
for (int x = sx; x < ex; x++) {
count++;
feature[hsv[x][y]]++;
}
}
if (count > 0) {
float scale = 1.0f / count;
for (int i = 0; i < featureSize(); i++) {
feature[i] *= scale;
}
}
return feature;
}
}
| 7,189 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/images/RGBFeature.java | package com.airbnb.aerosolve.core.images;
import java.awt.image.BufferedImage;
import java.lang.Override;
/*
Creates histograms of quantized RGB images.
Each pixel r,g,b is quantized into buckets of
8 colors each. In effect we take the high order
3 bits of each component and concatenate them
giving 512 total features.
*/
public class RGBFeature extends ImageFeature {
private int[][] rgb = null;
private BufferedImage imgRef = null;
@Override public String featureName() {
return "rgb";
}
// There are three rgb components each with
// 8 values so total 8 ^ 3 variations.
@Override public int featureSize() {
return 512;
}
@Override
public void analyze(BufferedImage image) {
imgRef = image;
int width = image.getWidth();
int height = image.getHeight();
rgb = new int[width][height];
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
int pixel = image.getRGB(x, y);
int token = 0;
for (int i = 0; i < 3; i++) {
// Mask out the high order 3 bits and shift
// right 5-bits to get the high order component.
// Left shift by the proper 3 bits to put them in place.
token |= ((pixel >> 5) & 0x7) << i * 3;
pixel = pixel >> 8;
}
rgb[x][y] = token;
}
}
}
@Override
public float[] extractFeature(int sx, int sy, int ex, int ey) {
float[] feature = new float[featureSize()];
if (sx >= ex || sy >= ey ||
ex > imgRef.getWidth() || ey > imgRef.getHeight()) {
return feature;
}
int count = 0;
for (int y = sy; y < ey; y++) {
for (int x = sx; x < ex; x++) {
count++;
feature[rgb[x][y]]++;
}
}
if (count > 0) {
float scale = 1.0f / count;
for (int i = 0; i < featureSize(); i++) {
feature[i] *= scale;
}
}
return feature;
}
}
| 7,190 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/images/ImageFeatureExtractor.java | package com.airbnb.aerosolve.core.images;
import java.awt.image.BufferedImage;
import java.io.Serializable;
import java.util.*;
import com.airbnb.aerosolve.core.FeatureVector;
/*
Calls all known features and adds them as dense features in a feature vector.
*/
public class ImageFeatureExtractor implements Serializable {
final List<ImageFeature> features;
private static final ThreadLocal<ImageFeatureExtractor> EXTRACTOR =
new ThreadLocal<ImageFeatureExtractor>() {
@Override protected ImageFeatureExtractor initialValue() {
return new ImageFeatureExtractor();
}
};
public static ImageFeatureExtractor getInstance() {
return EXTRACTOR.get();
}
private ImageFeatureExtractor() {
features = new ArrayList<ImageFeature>();
features.add(new RGBFeature());
features.add(new HOGFeature());
features.add(new LBPFeature());
features.add(new HSVFeature());
}
public FeatureVector getFeatureVector(BufferedImage image) {
FeatureVector featureVector = new FeatureVector();
Map<String, List<Double>> denseFeatures = new HashMap<>();
featureVector.setDenseFeatures(denseFeatures);
for (ImageFeature feature : features) {
List<Float> values = feature.extractFeatureSPMK(image);
List<Double> dblValues = new ArrayList<>();
for (Float f : values) {
dblValues.add(f.doubleValue());
}
denseFeatures.put(feature.featureName(), dblValues);
}
return featureVector;
}
}
| 7,191 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/features/FeatureMapping.java | package com.airbnb.aerosolve.core.features;
import lombok.Getter;
import java.util.*;
/*
Features coming from differenct sources, and output as array[],
FeatureMapping helps to save incoming feature in the right index of final output array[]
it use incoming feature names array as key to locate the index.
refer to ModelScorerTest.java as how to use FeatureMapping
*/
public class FeatureMapping {
public final static int DEFAULT_SIZE = 100;
@Getter
private String[] names;
private ArrayList<String> nameList;
@Getter
private final Map<Object, Entry> mapping;
public static final class Entry {
int start;
int length;
}
public FeatureMapping() {
this(DEFAULT_SIZE);
}
public FeatureMapping(int size) {
nameList = new ArrayList<>(size);
mapping = new HashMap<>(size);
}
// use name mapping array as key.
public void add(String[] names) {
add(names, names);
}
public void add(Object c, String[] names) {
assert(names.length > 0);
// should not add duplicated feature mapping
assert(mapping.get(c) == null);
Entry e = new Entry();
e.start = nameList.size();
e.length = names.length;
Collections.addAll(nameList, names);
mapping.put(c, e);
}
public void add(Class c, List<String> features) {
assert (features.size() > 0);
Entry e = new Entry();
e.start = nameList.size();
e.length = features.size();
for (String name : features) {
nameList.add(name);
}
mapping.put(c, e);
}
public void finish() {
names = new String[nameList.size()];
nameList.toArray(names);
nameList = null;
}
}
| 7,192 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/features/SparseLabeledPoint.java | package com.airbnb.aerosolve.core.features;
import lombok.Data;
import java.io.Serializable;
/**
* This is a compressed representation of a feature vector indexed via a feature index map. It
* captures values in flat representation for space and runtime efficiency during model training.
*/
@Data
public class SparseLabeledPoint implements Serializable {
public final boolean isTraining;
public final double label;
public final int[] indices;
public final float[] values;
public final int[] denseIndices;
public final float[][] denseValues;
}
| 7,193 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/features/FloatFamily.java | package com.airbnb.aerosolve.core.features;
import lombok.Getter;
import java.util.HashMap;
import java.util.Map;
public class FloatFamily extends FeatureFamily<Double> {
@Getter
private final Map<String, Double> features;
public FloatFamily(String familyName) {
super(familyName);
features = new HashMap<>();
}
protected void put(String name, Double feature) {
features.put(nameTransform(name), feature);
}
}
| 7,194 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/features/StringFamily.java | package com.airbnb.aerosolve.core.features;
import lombok.Getter;
import java.util.HashSet;
import java.util.Set;
public class StringFamily extends FeatureFamily<String> {
@Getter
private final Set<String> features;
public StringFamily(String familyName) {
super(familyName);
features = new HashSet<>();
}
@Override
protected void put(String name, String feature) {
features.add(feature);
}
public boolean add(String name, Boolean feature) {
String value = getBooleanFeatureAsString(name, feature);
return add(name, value);
}
protected String getBooleanFeatureAsString(String name, Boolean feature) {
if (feature) {
return name + ":T";
} else {
return name + ":F";
}
}
}
| 7,195 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/features/FeatureFamily.java | package com.airbnb.aerosolve.core.features;
import lombok.Getter;
public abstract class FeatureFamily <T> {
@Getter
private final String familyName;
public FeatureFamily(String familyName) {
this.familyName = familyName;
}
protected boolean isMyFamily(String name) {
return true;
}
protected String nameTransform(String name) {
return name;
}
public boolean add(String name, Object feature) {
if (isMyFamily(name)) {
put(nameTransform(name), (T) feature);
return true;
} else {
return false;
}
}
protected abstract void put(String name, T feature);
}
| 7,196 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/features/Features.java | package com.airbnb.aerosolve.core.features;
import com.airbnb.aerosolve.core.Example;
import com.airbnb.aerosolve.core.FeatureVector;
import com.airbnb.aerosolve.core.util.Util;
import com.google.common.annotations.VisibleForTesting;
import lombok.experimental.Builder;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
import java.lang.reflect.Field;
import java.util.*;
@Builder @Slf4j
public class Features {
// lower case label field will be inserted into Upper case LABEL family name.
public final static String LABEL = "LABEL";
public final static String LABEL_FEATURE_NAME = "";
public final static String MISS = "MISS";
// for string feature without family name
public final static String DEFAULT_STRING_FAMILY = "DEFAULT_STRING";
// for float feature without family name
public final static String DEFAULT_FLOAT_FAMILY = "DEFAULT_FLOAT";
// In RAW case, don't append feature name
public final static String RAW = "RAW";
private final static char FAMILY_SEPARATOR = '_';
private final static char TRUE_FEATURE = 'T';
private final static char FALSE_FEATURE = 'F';
private final static String STRING_FEATURE_SEPARATOR= ":";
public final String[] names;
public final Object[] values;
// names starting with _meta_ will be treated as metadata instead of features
private final static String METADATA_PREFIX = "_meta_";
/*
Util function to get features for FeatureMapping
*/
public static List<String> getGenericSortedFeatures(Class c) {
return getGenericSortedFeatures(c.getDeclaredFields());
}
public static List<String> getGenericSortedFeatures(Field[] fields) {
List<String> features = new ArrayList<>();
for (Field field : fields) {
features.add(field.getName());
}
// Sort the non-amenity features alphabetically
Collections.sort(features);
return features;
}
// TODO make it more generic, for example, taking care of dense feature
public Example toExample(boolean isMultiClass) {
assert (names.length == values.length);
Example example = new Example();
FeatureVector featureVector = new FeatureVector();
example.addToExample(featureVector);
// Set string features.
final Map<String, Set<String>> stringFeatures = new HashMap<>();
featureVector.setStringFeatures(stringFeatures);
final Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
featureVector.setFloatFeatures(floatFeatures);
// create LABEL family
floatFeatures.put(LABEL, new HashMap<>());
final Set<String> bias = new HashSet<>();
final Set<String> missing = new HashSet<>();
bias.add("B");
stringFeatures.put("BIAS", bias);
stringFeatures.put(MISS, missing);
// metadata map
final Map<String, String> metadata = new HashMap<>();
example.setMetadata(metadata);
for (int i = 0; i < names.length; i++) {
String name = names[i];
Object value = values[i];
if (isMetadata(name)) {
metadata.put(name.substring(METADATA_PREFIX.length()), value == null ? null : value.toString());
} else {
if (value == null) {
missing.add(name);
} else {
Pair<String, String> feature = getFamily(name);
if (value instanceof String) {
String str = (String) value;
if (isMultiClass && isLabel(feature)) {
addMultiClassLabel(str, floatFeatures);
} else {
addStringFeature(str, feature, stringFeatures);
}
} else if (value instanceof Boolean) {
Boolean b = (Boolean) value;
addBoolFeature(b, feature, stringFeatures);
} else {
addNumberFeature((Number) value, feature, floatFeatures);
}
}
}
}
return example;
}
private static boolean isMetadata(String name) {
return name.startsWith(METADATA_PREFIX);
}
@VisibleForTesting
static void addNumberFeature(
Number value, Pair<String, String> featurePair, Map<String, Map<String, Double>> floatFeatures) {
String family = getFloatFamily(featurePair);
Map<String, Double> feature = Util.getOrCreateFloatFeature(family, floatFeatures);
feature.put(featurePair.getRight(), value.doubleValue());
}
static String getFloatFamily(Pair<String, String> featurePair) {
String left = featurePair.getLeft();
return left.isEmpty()? DEFAULT_FLOAT_FAMILY :left;
}
static String getStringFamily(Pair<String, String> featurePair) {
String left = featurePair.getLeft();
return left.isEmpty()? DEFAULT_STRING_FAMILY :left;
}
@VisibleForTesting
static void addBoolFeature(
Boolean b, Pair<String, String> featurePair, Map<String, Set<String>> stringFeatures) {
String family = getStringFamily(featurePair);
Set<String> feature = Util.getOrCreateStringFeature(family, stringFeatures);
String featureName = featurePair.getRight();
char str = b ? TRUE_FEATURE : FALSE_FEATURE;
feature.add(featureName + STRING_FEATURE_SEPARATOR + str);
}
@VisibleForTesting
static void addStringFeature(
String str, Pair<String, String> featurePair, Map<String, Set<String>> stringFeatures) {
String family = getStringFamily(featurePair);
Set<String> feature = Util.getOrCreateStringFeature(family, stringFeatures);
String featureName = featurePair.getRight();
if (featureName.equals(RAW)) {
feature.add(str);
} else {
feature.add(featureName + STRING_FEATURE_SEPARATOR + str);
}
}
// string feature is concatenated by : the prefix before : is feature name
// RAW feature has no : so just return the RAW
// this is used in StringCrossFloatTransform so that
// we can cross Raw feature as well as other string features
public static String getStringFeatureName(String feature) {
String[] tokens = feature.split(STRING_FEATURE_SEPARATOR);
if (tokens.length == 1) {
return RAW;
} else {
return tokens[0];
}
}
@VisibleForTesting
static void addMultiClassLabel(String str, Map<String, Map<String, Double>> floatFeatures) {
String[] labels = str.split(",");
for (String s: labels) {
String[] labelTokens = s.split(":");
if (labelTokens.length != 2) {
throw new RuntimeException(String.format(
"MultiClass LABEL \"%s\" not in format [label1]:[weight1],...!", str));
}
Map<String, Double> feature = Util.getOrCreateFloatFeature(LABEL, floatFeatures);
feature.put(labelTokens[0], Double.valueOf(labelTokens[1]));
}
}
static boolean isLabel(Pair<String, String> feature) {
return feature.getRight().equals(LABEL_FEATURE_NAME);
}
@VisibleForTesting
static Pair<String, String> getFamily(String name) {
int pos = name.indexOf(FAMILY_SEPARATOR);
if (pos == -1) {
if (name.compareToIgnoreCase(LABEL) == 0) {
return new ImmutablePair<>(LABEL, LABEL_FEATURE_NAME) ;
} else if (!name.isEmpty()){
return new ImmutablePair<>("", name) ;
} else {
throw new RuntimeException("Column name empty");
}
} else if (pos == 0) {
throw new RuntimeException("Column name can't prefix with _! " + name);
} else {
return new ImmutablePair<>(name.substring(0, pos),
name.substring(pos + 1));
}
}
}
| 7,197 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/features/FeatureGen.java | package com.airbnb.aerosolve.core.features;
/*
use Float.MIN_VALUE as NULL for the float feature.
*/
public class FeatureGen {
private final FeatureMapping mapping;
private Object[] values;
public FeatureGen(FeatureMapping mapping) {
this.mapping = mapping;
values = new Object[mapping.getNames().length];
}
public void add(float[] features, Object c) {
FeatureMapping.Entry e = mapping.getMapping().get(c);
assert(e.length == features.length);
// can't do System.arraycopy(features, 0, values, e.start, e.length);
// due to Float.MIN_VALUE means NULL
for (int i = 0; i < e.length; i++) {
if (features[i] != Float.MIN_VALUE) {
values[i + e.start] = new Double(features[i]);
}
}
}
public void add(Object[] features, Object c) {
FeatureMapping.Entry e = mapping.getMapping().get(c);
assert(e.length == features.length);
System.arraycopy(features, 0, values, e.start, e.length);
}
public Features gen() {
return Features.builder().
names(mapping.getNames()).
values(values).
build();
}
}
| 7,198 |
0 | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core | Create_ds/aerosolve/core/src/main/java/com/airbnb/aerosolve/core/features/FeatureVectorGen.java | package com.airbnb.aerosolve.core.features;
import com.airbnb.aerosolve.core.Example;
import com.airbnb.aerosolve.core.FeatureVector;
import java.util.*;
/*
Generate Example from input features and defined featureFamily.
refer to ModelScorerTest.java as how to use FeatureVectorGen
*/
public class FeatureVectorGen {
// TODO add a new function to consider dense feature.
public static FeatureVector toFeatureVector(Features features,
List<StringFamily> stringFamilies,
List<FloatFamily> floatFamilies) {
FeatureVector featureVector = new FeatureVector();
// Set string features.
final Map<String, Set<String>> stringFeatures = new HashMap<>();
featureVector.setStringFeatures(stringFeatures);
setBIAS(stringFeatures);
for (StringFamily featureFamily : stringFamilies) {
stringFeatures.put(featureFamily.getFamilyName(), featureFamily.getFeatures());
}
final Map<String, Map<String, Double>> floatFeatures = new HashMap<>();
featureVector.setFloatFeatures(floatFeatures);
for (FloatFamily featureFamily : floatFamilies) {
floatFeatures.put(featureFamily.getFamilyName(), featureFamily.getFeatures());
}
for (int i = 0; i < features.names.length; ++i) {
Object feature = features.values[i];
if (feature != null) {
// Integer type = features.types[i];
String name = features.names[i];
if (feature instanceof Double || feature instanceof Float ||
feature instanceof Integer || feature instanceof Long) {
for (FloatFamily featureFamily : floatFamilies) {
if (featureFamily.add(name, feature)) break;
}
} else if (feature instanceof String) {
for (StringFamily featureFamily : stringFamilies) {
if (featureFamily.add(name, feature)) break;
}
} else if (feature instanceof Boolean){
for (StringFamily featureFamily : stringFamilies) {
if (featureFamily.add(name, (Boolean) feature)) break;
}
}
}
}
return featureVector;
}
public static Example toSingleFeatureVectorExample(Features features,
List<StringFamily> stringFamilies,
List<FloatFamily> floatFamilies) {
Example example = new Example();
FeatureVector featureVector = toFeatureVector(
features, stringFamilies, floatFamilies);
example.addToExample(featureVector);
return example;
}
protected static void setBIAS(final Map<String, Set<String>> stringFeatures) {
final Set<String> bias = new HashSet<>();
bias.add("B");
stringFeatures.put("BIAS", bias);
}
}
| 7,199 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.