org.datavec.api.writable.WritableType Java Examples

public static Comparator<Writable> forType(WritableType type, boolean ascending){
    Comparator<Writable> c;
    switch (type){
        case Byte:
        case Int:
            c = new IntWritableComparator();
            break;
        case Double:
            c = new DoubleWritableComparator();
            break;
        case Float:
            c = new FloatWritableComparator();
            break;
        case Long:
            c = new LongWritableComparator();
            break;
        case Text:
            c = new TextWritableComparator();
            break;
        case Boolean:
        case NDArray:
        case Image:
        case Null:
        default:
            throw new UnsupportedOperationException("No built-in comparator for writable type: " + type);
    }
    if(ascending){
        return c;
    }
    return new ReverseComparator<>(c);
}
 

@Override
public IntWritable map(Writable writable) {
    if(writable.getType() == WritableType.Int){
        return (IntWritable)writable;
    }
    return new IntWritable(writable.toInt());
}
 

@Override
public DoubleWritable map(Writable writable) {
    if(writable.getType() == WritableType.Double){
        return (DoubleWritable)writable;
    }
    return new DoubleWritable(writable.toDouble());
}
 

public static Comparator<Writable> forType(WritableType type, boolean ascending){
    Comparator<Writable> c;
    switch (type){
        case Byte:
        case Int:
            c = new IntWritableComparator();
            break;
        case Double:
            c = new DoubleWritableComparator();
            break;
        case Float:
            c = new FloatWritableComparator();
            break;
        case Long:
            c = new LongWritableComparator();
            break;
        case Text:
            c = new TextWritableComparator();
            break;
        case Boolean:
        case NDArray:
        case Image:
        case Null:
        default:
            throw new UnsupportedOperationException("No built-in comparator for writable type: " + type);
    }
    if(ascending){
        return c;
    }
    return new ReverseComparator<>(c);
}
 

@Override
public DoubleWritable map(Writable writable) {
    if(writable.getType() == WritableType.Double){
        return (DoubleWritable)writable;
    }
    return new DoubleWritable(writable.toDouble());
}
 

@Override
public FloatWritable map(Writable writable) {
    if(writable.getType() == WritableType.Double){
        return (FloatWritable)writable;
    }
    return new FloatWritable(writable.toFloat());
}
 

@Override
public IntWritable map(Writable writable) {
    if(writable.getType() == WritableType.Int){
        return (IntWritable)writable;
    }
    return new IntWritable(writable.toInt());
}
 

private boolean allNdArray(Record[] records) {
    boolean isAllNdArrays = true;
    for (Record record : records) {
        if (record.getRecord().size() != 1 && record.getRecord().get(0).getType() != WritableType.NDArray) {
            isAllNdArrays = false;
            break;
        }
    }

    return isAllNdArrays;
}
 

@Override
public void writeType(DataOutput out) throws IOException {
    out.writeShort(WritableType.Image.typeIdx());
}
 

@Override
public WritableType getType() {
    throw new UnsupportedOperationException();
}
 

public static Comparator<Writable> forType(WritableType type) {
    return forType(type, true);
}
 

@Override
public WritableType getType(){
    throw new UnsupportedOperationException();
}
 

@Override
public WritableType getType() {
    throw new UnsupportedOperationException();
}
 

@Override
public WritableType getType() {
    return WritableType.Image;
}
 

@Override
public void writeType(DataOutput out) throws IOException {
    out.writeShort(WritableType.Image.typeIdx());
}
 

@Override
public WritableType getType() {
    return WritableType.Image;
}
 

@Override
public WritableType getType() {
    throw new UnsupportedOperationException();
}
 

@Override
public WritableType getType(){
    throw new UnsupportedOperationException();
}
 

public static Comparator<Writable> forType(WritableType type) {
    return forType(type, true);
}
 

@Override
public WritableType getType() {
    throw new UnsupportedOperationException();
}
 

/**
 *
 * @param outputDir           Output directory for the map file(s)
 * @param convertTextTo       If null: Make no changes to Text writable objects. If non-null, Text writable instances
 *                            will be converted to this type. This is useful, when would rather store numerical values
 *                            even if the original record reader produces strings/text.
 */
public MapFileSequenceRecordWriter(@NonNull File outputDir, WritableType convertTextTo) {
    this(outputDir, DEFAULT_MAP_FILE_SPLIT_SIZE, convertTextTo);
}
 

/**
 *
 * @param outputDir           Output directory for the map file(s)
 * @param convertTextTo       If null: Make no changes to Text writable objects. If non-null, Text writable instances
 *                            will be converted to this type. This is useful, when would rather store numerical values
 *                            even if the original record reader produces strings/text.
 */
public MapFileRecordWriter(@NonNull File outputDir, WritableType convertTextTo) {
    this(outputDir, DEFAULT_MAP_FILE_SPLIT_SIZE, convertTextTo);
}
 

/**
 *
 * @param outputDir           Output directory for the map file(s)
 * @param mapFileSplitSize    Split size for the map file: if 0, use a single map file for all output. If > 0,
 *                            multiple map files will be used: each will contain a maximum of mapFileSplitSize
 *                            examples. This can be used to avoid having a single multi gigabyte map file, which may
 *                            be undesirable in some cases (transfer across the network, for example).
 * @param convertTextTo       If null: Make no changes to Text writable objects. If non-null, Text writable instances
 *                            will be converted to this type. This is useful, when would rather store numerical values
 *                            even if the original record reader produces strings/text.
 */
public MapFileRecordWriter(@NonNull File outputDir, int mapFileSplitSize, WritableType convertTextTo) {
    super(outputDir, mapFileSplitSize, convertTextTo);
}
 

/**
 *
 * @param outputDir           Output directory for the map file(s)
 * @param mapFileSplitSize    Split size for the map file: if 0, use a single map file for all output. If > 0,
 *                            multiple map files will be used: each will contain a maximum of mapFileSplitSize
 *                            examples. This can be used to avoid having a single multi gigabyte map file, which may
 *                            be undesirable in some cases (transfer across the network, for example).
 * @param convertTextTo       If null: Make no changes to Text writable objects. If non-null, Text writable instances
 *                            will be converted to this type. This is useful, when would rather store numerical values
 *                            even if the original record reader produces strings/text.
 * @param indexInterval       Index interval for the Map file. Defaults to 1, which is suitable for most cases
 * @param filenamePattern     The naming pattern for the map files. Used with String.format(pattern, int)
 * @param hadoopConfiguration Hadoop configuration.
 */
public MapFileSequenceRecordWriter(@NonNull File outputDir, int mapFileSplitSize, WritableType convertTextTo,
                                   int indexInterval, String filenamePattern,
                                   org.apache.hadoop.conf.Configuration hadoopConfiguration) {
    super(outputDir, mapFileSplitSize, convertTextTo, indexInterval, filenamePattern, hadoopConfiguration);
}
 

/**
 *
 * @param outputDir           Output directory for the map file(s)
 * @param mapFileSplitSize    Split size for the map file: if 0, use a single map file for all output. If > 0,
 *                            multiple map files will be used: each will contain a maximum of mapFileSplitSize
 *                            examples. This can be used to avoid having a single multi gigabyte map file, which may
 *                            be undesirable in some cases (transfer across the network, for example).
 * @param convertTextTo       If null: Make no changes to Text writable objects. If non-null, Text writable instances
 *                            will be converted to this type. This is useful, when would rather store numerical values
 *                            even if the original record reader produces strings/text.
 * @param indexInterval       Index interval for the Map file. Defaults to 1, which is suitable for most cases
 * @param hadoopConfiguration Hadoop configuration.
 */
public MapFileSequenceRecordWriter(@NonNull File outputDir, int mapFileSplitSize, WritableType convertTextTo,
                                   int indexInterval, org.apache.hadoop.conf.Configuration hadoopConfiguration) {
    super(outputDir, mapFileSplitSize, convertTextTo, indexInterval, hadoopConfiguration);
}
 

/**
 *
 * @param outputDir           Output directory for the map file(s)
 * @param mapFileSplitSize    Split size for the map file: if 0, use a single map file for all output. If > 0,
 *                            multiple map files will be used: each will contain a maximum of mapFileSplitSize
 *                            examples. This can be used to avoid having a single multi gigabyte map file, which may
 *                            be undesirable in some cases (transfer across the network, for example).
 * @param convertTextTo       If null: Make no changes to Text writable objects. If non-null, Text writable instances
 *                            will be converted to this type. This is useful, when would rather store numerical values
 *                            even if the original record reader produces strings/text.
 * @param hadoopConfiguration Hadoop configuration.
 */
public MapFileSequenceRecordWriter(@NonNull File outputDir, int mapFileSplitSize, WritableType convertTextTo,
                                   org.apache.hadoop.conf.Configuration hadoopConfiguration) {
    super(outputDir, mapFileSplitSize, convertTextTo, DEFAULT_INDEX_INTERVAL, hadoopConfiguration);
}
 

/**
 *
 * @param outputDir           Output directory for the map file(s)
 * @param mapFileSplitSize    Split size for the map file: if 0, use a single map file for all output. If > 0,
 *                            multiple map files will be used: each will contain a maximum of mapFileSplitSize
 *                            examples. This can be used to avoid having a single multi gigabyte map file, which may
 *                            be undesirable in some cases (transfer across the network, for example).
 * @param convertTextTo       If null: Make no changes to Text writable objects. If non-null, Text writable instances
 *                            will be converted to this type. This is useful, when would rather store numerical values
 *                            even if the original record reader produces strings/text.
 */
public MapFileSequenceRecordWriter(@NonNull File outputDir, int mapFileSplitSize, WritableType convertTextTo) {
    super(outputDir, mapFileSplitSize, convertTextTo);
}
 

/**
 *
 * @param outputDir           Output directory for the map file(s)
 * @param mapFileSplitSize    Split size for the map file: if 0, use a single map file for all output. If > 0,
 *                            multiple map files will be used: each will contain a maximum of mapFileSplitSize
 *                            examples. This can be used to avoid having a single multi gigabyte map file, which may
 *                            be undesirable in some cases (transfer across the network, for example).
 * @param convertTextTo       If null: Make no changes to Text writable objects. If non-null, Text writable instances
 *                            will be converted to this type. This is useful, when would rather store numerical values
 *                            even if the original record reader produces strings/text.
 * @param indexInterval       Index interval for the Map file. Defaults to 1, which is suitable for most cases
 * @param filenamePattern     The naming pattern for the map files. Used with String.format(pattern, int)
 * @param hadoopConfiguration Hadoop configuration.
 */
public MapFileRecordWriter(@NonNull File outputDir, int mapFileSplitSize, WritableType convertTextTo,
                           int indexInterval, String filenamePattern,
                           org.apache.hadoop.conf.Configuration hadoopConfiguration) {
    super(outputDir, mapFileSplitSize, convertTextTo, indexInterval, filenamePattern, hadoopConfiguration);
}
 

/**
 *
 * @param outputDir           Output directory for the map file(s)
 * @param mapFileSplitSize    Split size for the map file: if 0, use a single map file for all output. If > 0,
 *                            multiple map files will be used: each will contain a maximum of mapFileSplitSize
 *                            examples. This can be used to avoid having a single multi gigabyte map file, which may
 *                            be undesirable in some cases (transfer across the network, for example).
 * @param convertTextTo       If null: Make no changes to Text writable objects. If non-null, Text writable instances
 *                            will be converted to this type. This is useful, when would rather store numerical values
 *                            even if the original record reader produces strings/text.
 * @param indexInterval       Index interval for the Map file. Defaults to 1, which is suitable for most cases
 * @param filenamePattern     The naming pattern for the map files. Used with String.format(pattern, int)
 * @param hadoopConfiguration Hadoop configuration.
 */
public MapFileRecordWriter(@NonNull File outputDir, int mapFileSplitSize, WritableType convertTextTo,
                           int indexInterval, String filenamePattern,
                           org.apache.hadoop.conf.Configuration hadoopConfiguration) {
    super(outputDir, mapFileSplitSize, convertTextTo, indexInterval, filenamePattern, hadoopConfiguration);
}
 

/**
 *
 * @param outputDir           Output directory for the map file(s)
 * @param mapFileSplitSize    Split size for the map file: if 0, use a single map file for all output. If > 0,
 *                            multiple map files will be used: each will contain a maximum of mapFileSplitSize
 *                            examples. This can be used to avoid having a single multi gigabyte map file, which may
 *                            be undesirable in some cases (transfer across the network, for example).
 * @param convertTextTo       If null: Make no changes to Text writable objects. If non-null, Text writable instances
 *                            will be converted to this type. This is useful, when would rather store numerical values
 *                            even if the original record reader produces strings/text.
 * @param indexInterval       Index interval for the Map file. Defaults to 1, which is suitable for most cases
 * @param hadoopConfiguration Hadoop configuration.
 */
public MapFileRecordWriter(@NonNull File outputDir, int mapFileSplitSize, WritableType convertTextTo,
                           int indexInterval, org.apache.hadoop.conf.Configuration hadoopConfiguration) {
    super(outputDir, mapFileSplitSize, convertTextTo, indexInterval, hadoopConfiguration);
}