core/com.spotify.featran

com.spotify.featran

package com.spotify.featran

Type members

Classlikes

trait CanBuild[T, M <: ([_$1] =>> Any)] extends Serializable
Companion
object
object CanBuild
Companion
class
@implicitNotFound("Could not find an instance of CollectionType for ${M}") @typeclass
trait CollectionType[M <: ([_$1] =>> Any)] extends Serializable
Type class for collections to extract features from.
Type Params
M
collection type
Companion
object
object CollectionType
Companion
class
object CrossingFeatureBuilder
class Feature[T, A, B, C] extends Serializable
@implicitNotFound("Could not find an instance of FeatureBuilder for ${T}") @typeclass
trait FeatureBuilder[T] extends Serializable
Type class for types to build feature into.
Type Params
T
output feature type
Companion
object
object FeatureBuilder
Companion
class
class FeatureExtractor[M <: ([_$1] =>> Any), T] extends Serializable
Encapsulate features extracted from a FeatureSpec.
Type Params
M
input collection type, e.g. Array, List
T
input record type to extract features from
sealed trait FeatureRejection
Companion
object
object FeatureRejection
Companion
class
case class FeatureResult[F, T](value: F, rejections: Map[String, FeatureRejection], original: T)
object FeatureSpec extends FeatureSpecCompat
Companion object for FeatureSpec.
Companion
class
class FeatureSpec[T]
Encapsulate specification for feature extraction and transformation.
Type Params
T
input record type to extract features from
Companion
object
trait FeatureSpecCompat
object FlatConverter
Companion to FlatReader. Sometimes for serialization and compatability reasons it
is better to write out data in an intermediate format such as JSON or tf.examples to
interface with storage or other systems. This class uses the functions internal to a spec
to write out the data into a new flat format.
object FlatExtractor
Sometimes it is useful to store the features in an intermediate state in normally
a flat version like Examples or maybe JSON. This makes it easier to interface with
other systems.
@implicitNotFound("Could not find an instance of FlatReader for ${T}") @typeclass
trait FlatReader[T] extends Serializable
TypeClass that is used to read data from flat files. The requirement is that each
feature comes from the same type and can be looked up by name.
Type Params
T
The intermediate storage format for each feature.
Companion
object
object FlatReader
Companion
class
@implicitNotFound("Could not find an instance of FlatWriter for ${T}") @typeclass
trait FlatWriter[+T] extends Serializable
TypeClass for implementing the writer to a flat format keyed by name
Companion
object
object FlatWriter
Companion
class
@implicitNotFound("Could not find an instance of FloatingPoint for ${T}") @typeclass
trait FloatingPoint[T] extends Serializable
Type class for floating point primitives.
Companion
object
object FloatingPoint
Companion
class
class MultiFeatureExtractor[M <: ([_$1] =>> Any), T] extends Serializable
Encapsulate features extracted from a MultiFeatureSpec.
Allows separation back into specs by names or vectors.
Type Params
M
input collection type, e.g. Array, List
T
input record type to extract features from
object MultiFeatureSpec
Companion object for MultiFeatureSpec.
Companion
class
class MultiFeatureSpec[T](val mapping: Map[String, Int], val features: Array[Feature[T, , , ]], val crossings: Crossings)
Wrapper for FeatureSpec that allows for combination and separation of different specs.
Companion
object
case class NamedSparseArray[T](indices: Array[Int], values: Array[T], length: Int, names: Seq[String])
A SparseArray with names of non-zero entries.
object RecordExtractor
Companion
class
class RecordExtractor[T, F]
Encapsulate RecordExtractor for extracting individual records.
Companion
object
case class SparseArray[T](indices: Array[Int], values: Array[T], length: Int)
A sparse representation of an array using two arrays for indices and
values of non-zero entries.