path stringlengths 26 218 | content stringlengths 0 231k |
|---|---|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/list_tweets/decorator/ListConversationServiceCandidateDecorator.scala | package com.twitter.home_mixer.product.list_tweets.decorator
import com.twitter.home_mixer.functional_component.decorator.builder.HomeConversationModuleMetadataBuilder
import com.twitter.home_mixer.functional_component.decorator.builder.ListClientEventDetailsBuilder
import com.twitter.home_mixer.model.HomeFeatures.ConversationModuleFocalTweetIdFeature
import com.twitter.product_mixer.component_library.decorator.urt.UrtItemCandidateDecorator
import com.twitter.product_mixer.component_library.decorator.urt.UrtMultipleModulesDecorator
import com.twitter.product_mixer.component_library.decorator.urt.builder.item.tweet.TweetCandidateUrtItemBuilder
import com.twitter.product_mixer.component_library.decorator.urt.builder.metadata.ClientEventInfoBuilder
import com.twitter.product_mixer.component_library.decorator.urt.builder.timeline_module.StaticModuleDisplayTypeBuilder
import com.twitter.product_mixer.component_library.decorator.urt.builder.timeline_module.TimelineModuleBuilder
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.model.marshalling.response.urt.EntryNamespace
import com.twitter.product_mixer.core.model.marshalling.response.urt.timeline_module.VerticalConversation
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.timelines.injection.scribe.InjectionScribeUtil
import com.twitter.timelineservice.suggests.{thriftscala => st}
object ListConversationServiceCandidateDecorator {
private val ConversationModuleNamespace = EntryNamespace("list-conversation")
def apply(): Some[UrtMultipleModulesDecorator[PipelineQuery, TweetCandidate, Long]] = {
val suggestType = st.SuggestType.OrganicListTweet
val component = InjectionScribeUtil.scribeComponent(suggestType).get
val clientEventInfoBuilder = ClientEventInfoBuilder(
component = component,
detailsBuilder = Some(ListClientEventDetailsBuilder(st.SuggestType.OrganicListTweet))
)
val tweetItemBuilder = TweetCandidateUrtItemBuilder(
clientEventInfoBuilder = clientEventInfoBuilder
)
val moduleBuilder = TimelineModuleBuilder(
entryNamespace = ConversationModuleNamespace,
clientEventInfoBuilder = clientEventInfoBuilder,
displayTypeBuilder = StaticModuleDisplayTypeBuilder(VerticalConversation),
metadataBuilder = Some(HomeConversationModuleMetadataBuilder())
)
Some(
UrtMultipleModulesDecorator(
urtItemCandidateDecorator = UrtItemCandidateDecorator(tweetItemBuilder),
moduleBuilder = moduleBuilder,
groupByKey = (_, _, candidateFeatures) =>
candidateFeatures.getOrElse(ConversationModuleFocalTweetIdFeature, None)
))
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/list_tweets/decorator/builder/BUILD.bazel | scala_library(
sources = ["*.scala"],
compiler_option_sets = ["fatal_warnings"],
strict_deps = True,
tags = ["bazel-compatible"],
dependencies = [
"home-mixer/server/src/main/scala/com/twitter/home_mixer/model",
"product-mixer/core/src/main/scala/com/twitter/product_mixer/core/functional_component/decorator/urt/builder",
],
)
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/list_tweets/model/BUILD.bazel | scala_library(
sources = ["*.scala"],
compiler_option_sets = ["fatal_warnings"],
strict_deps = True,
tags = ["bazel-compatible"],
dependencies = [
"home-mixer/server/src/main/scala/com/twitter/home_mixer/model",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/model/request",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/list_tweets/param",
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/model/cursor",
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/model/query/ads",
"product-mixer/core/src/main/scala/com/twitter/product_mixer/core/pipeline",
],
exports = [
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/model/cursor",
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/model/query/ads",
"product-mixer/core/src/main/scala/com/twitter/product_mixer/core/pipeline",
],
)
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/list_tweets/model/ListTweetsQuery.scala | package com.twitter.home_mixer.product.list_tweets.model
import com.twitter.adserver.thriftscala.HomeTimelineType
import com.twitter.adserver.thriftscala.TimelineRequestParams
import com.twitter.dspbidder.commons.{thriftscala => dsp}
import com.twitter.home_mixer.model.HomeAdsQuery
import com.twitter.home_mixer.model.request.DeviceContext
import com.twitter.home_mixer.model.request.HasListId
import com.twitter.home_mixer.model.request.ListTweetsProduct
import com.twitter.product_mixer.component_library.model.cursor.UrtOrderedCursor
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.model.marshalling.request._
import com.twitter.product_mixer.core.pipeline.HasPipelineCursor
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.timelines.configapi.Params
case class ListTweetsQuery(
override val params: Params,
override val clientContext: ClientContext,
override val pipelineCursor: Option[UrtOrderedCursor],
override val requestedMaxResults: Option[Int],
override val debugOptions: Option[DebugOptions],
override val features: Option[FeatureMap],
override val listId: Long,
override val deviceContext: Option[DeviceContext],
override val dspClientContext: Option[dsp.DspClientContext])
extends PipelineQuery
with HasPipelineCursor[UrtOrderedCursor]
with HasListId
with HomeAdsQuery {
override val product: Product = ListTweetsProduct
override def withFeatureMap(features: FeatureMap): ListTweetsQuery =
copy(features = Some(features))
override val timelineRequestParams: Option[TimelineRequestParams] =
Some(TimelineRequestParams(homeTimelineType = Some(HomeTimelineType.HomeLatest)))
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/list_tweets/param/BUILD.bazel | scala_library(
sources = ["*.scala"],
compiler_option_sets = ["fatal_warnings"],
strict_deps = True,
tags = ["bazel-compatible"],
dependencies = [
"3rdparty/jvm/javax/inject:javax.inject",
"configapi/configapi-core/src/main/scala/com/twitter/timelines/configapi",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/param/decider",
"product-mixer/core/src/main/scala/com/twitter/product_mixer/core/product",
],
)
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/list_tweets/param/ListTweetsParam.scala | package com.twitter.home_mixer.product.list_tweets.param
import com.twitter.timelines.configapi.FSBoundedParam
import com.twitter.timelines.configapi.FSParam
object ListTweetsParam {
val SupportedClientFSName = "list_tweets_supported_client"
object EnableAdsCandidatePipelineParam
extends FSParam[Boolean](
name = "list_tweets_enable_ads",
default = false
)
object ServerMaxResultsParam
extends FSBoundedParam[Int](
name = "list_tweets_server_max_results",
default = 100,
min = 1,
max = 500
)
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/list_tweets/param/ListTweetsParamConfig.scala | package com.twitter.home_mixer.product.list_tweets.param
import com.twitter.home_mixer.param.decider.DeciderKey
import com.twitter.home_mixer.product.list_tweets.param.ListTweetsParam.EnableAdsCandidatePipelineParam
import com.twitter.home_mixer.product.list_tweets.param.ListTweetsParam.ServerMaxResultsParam
import com.twitter.home_mixer.product.list_tweets.param.ListTweetsParam.SupportedClientFSName
import com.twitter.product_mixer.core.product.ProductParamConfig
import com.twitter.servo.decider.DeciderKeyName
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class ListTweetsParamConfig @Inject() () extends ProductParamConfig {
override val enabledDeciderKey: DeciderKeyName = DeciderKey.EnableListTweetsProduct
override val supportedClientFSName: String = SupportedClientFSName
override val booleanFSOverrides =
Seq(EnableAdsCandidatePipelineParam)
override val boundedIntFSOverrides = Seq(
ServerMaxResultsParam
)
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/BUILD.bazel | scala_library(
sources = ["*.scala"],
compiler_option_sets = ["fatal_warnings"],
strict_deps = True,
tags = ["bazel-compatible"],
dependencies = [
"explore/explore-ranker/thrift/src/main/thrift:thrift-scala",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/functional_component/feature_hydrator",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/functional_component/filter",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/functional_component/side_effect",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/model",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/model/request",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/param",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/candidate_pipeline",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/offline_aggregates",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/real_time_aggregates",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/filter",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/marshaller",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/model",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/param",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/scoring_pipeline",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/selector",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/side_effect",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/service",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/util",
"home-mixer/thrift/src/main/thrift:thrift-scala",
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/feature_hydrator/query/async",
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/feature_hydrator/query/impressed_tweets",
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/feature_hydrator/query/param_gated",
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/feature_hydrator/query/social_graph",
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/filter",
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/premarshaller/urt",
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/selector",
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/side_effect",
"product-mixer/core/src/main/scala/com/twitter/product_mixer/core/pipeline/product",
"product-mixer/core/src/main/scala/com/twitter/product_mixer/core/pipeline/recommendation",
"product-mixer/core/src/main/scala/com/twitter/product_mixer/core/product",
],
)
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/ScoredTweetsProductPipelineConfig.scala | package com.twitter.home_mixer.product.scored_tweets
import com.twitter.home_mixer.model.HomeFeatures.ServedTweetIdsFeature
import com.twitter.home_mixer.model.HomeFeatures.TimelineServiceTweetsFeature
import com.twitter.home_mixer.model.request.HomeMixerRequest
import com.twitter.home_mixer.model.request.ScoredTweetsProduct
import com.twitter.home_mixer.model.request.ScoredTweetsProductContext
import com.twitter.home_mixer.product.scored_tweets.model.ScoredTweetsQuery
import com.twitter.home_mixer.product.scored_tweets.param.ScoredTweetsParam.ServerMaxResultsParam
import com.twitter.home_mixer.product.scored_tweets.param.ScoredTweetsParamConfig
import com.twitter.home_mixer.service.HomeMixerAccessPolicy.DefaultHomeMixerAccessPolicy
import com.twitter.home_mixer.{thriftscala => t}
import com.twitter.product_mixer.component_library.premarshaller.cursor.UrtCursorSerializer
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.common.access_policy.AccessPolicy
import com.twitter.product_mixer.core.model.common.identifier.ComponentIdentifier
import com.twitter.product_mixer.core.model.common.identifier.ProductPipelineIdentifier
import com.twitter.product_mixer.core.model.marshalling.request.Product
import com.twitter.product_mixer.core.pipeline.PipelineConfig
import com.twitter.product_mixer.core.pipeline.pipeline_failure.BadRequest
import com.twitter.product_mixer.core.pipeline.pipeline_failure.PipelineFailure
import com.twitter.product_mixer.core.pipeline.product.ProductPipelineConfig
import com.twitter.product_mixer.core.product.ProductParamConfig
import com.twitter.timelines.configapi.Params
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class ScoredTweetsProductPipelineConfig @Inject() (
scoredTweetsRecommendationPipelineConfig: ScoredTweetsRecommendationPipelineConfig,
scoredTweetsParamConfig: ScoredTweetsParamConfig)
extends ProductPipelineConfig[HomeMixerRequest, ScoredTweetsQuery, t.ScoredTweets] {
override val identifier: ProductPipelineIdentifier = ProductPipelineIdentifier("ScoredTweets")
override val product: Product = ScoredTweetsProduct
override val paramConfig: ProductParamConfig = scoredTweetsParamConfig
override def pipelineQueryTransformer(
request: HomeMixerRequest,
params: Params
): ScoredTweetsQuery = {
val context = request.productContext match {
case Some(context: ScoredTweetsProductContext) => context
case _ => throw PipelineFailure(BadRequest, "ScoredTweetsProductContext not found")
}
val featureMap = FeatureMapBuilder()
.add(ServedTweetIdsFeature, context.servedTweetIds.getOrElse(Seq.empty))
.add(TimelineServiceTweetsFeature, context.backfillTweetIds.getOrElse(Seq.empty))
.build()
ScoredTweetsQuery(
params = params,
clientContext = request.clientContext,
pipelineCursor =
request.serializedRequestCursor.flatMap(UrtCursorSerializer.deserializeOrderedCursor),
requestedMaxResults = Some(params(ServerMaxResultsParam)),
debugOptions = request.debugParams.flatMap(_.debugOptions),
features = Some(featureMap),
deviceContext = context.deviceContext,
seenTweetIds = context.seenTweetIds,
qualityFactorStatus = None
)
}
override val pipelines: Seq[PipelineConfig] = Seq(scoredTweetsRecommendationPipelineConfig)
override def pipelineSelector(query: ScoredTweetsQuery): ComponentIdentifier =
scoredTweetsRecommendationPipelineConfig.identifier
override val debugAccessPolicies: Set[AccessPolicy] = DefaultHomeMixerAccessPolicy
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/ScoredTweetsRecommendationPipelineConfig.scala | package com.twitter.home_mixer.product.scored_tweets
import com.twitter.conversions.DurationOps._
import com.twitter.home_mixer.functional_component.feature_hydrator.FeedbackHistoryQueryFeatureHydrator
import com.twitter.home_mixer.functional_component.feature_hydrator.ImpressionBloomFilterQueryFeatureHydrator
import com.twitter.home_mixer.functional_component.feature_hydrator.RealGraphInNetworkScoresQueryFeatureHydrator
import com.twitter.home_mixer.functional_component.feature_hydrator.RequestQueryFeatureHydrator
import com.twitter.home_mixer.functional_component.feature_hydrator.TweetImpressionsQueryFeatureHydrator
import com.twitter.home_mixer.functional_component.filter.FeedbackFatigueFilter
import com.twitter.home_mixer.functional_component.filter.PreviouslySeenTweetsFilter
import com.twitter.home_mixer.functional_component.filter.PreviouslyServedTweetsFilter
import com.twitter.home_mixer.functional_component.filter.RejectTweetFromViewerFilter
import com.twitter.home_mixer.functional_component.filter.RetweetDeduplicationFilter
import com.twitter.home_mixer.functional_component.side_effect.PublishClientSentImpressionsEventBusSideEffect
import com.twitter.home_mixer.functional_component.side_effect.PublishClientSentImpressionsManhattanSideEffect
import com.twitter.home_mixer.functional_component.side_effect.PublishImpressionBloomFilterSideEffect
import com.twitter.home_mixer.functional_component.side_effect.UpdateLastNonPollingTimeSideEffect
import com.twitter.home_mixer.model.HomeFeatures.ExclusiveConversationAuthorIdFeature
import com.twitter.home_mixer.model.HomeFeatures.InNetworkFeature
import com.twitter.home_mixer.model.HomeFeatures.InReplyToTweetIdFeature
import com.twitter.home_mixer.model.HomeFeatures.IsSupportAccountReplyFeature
import com.twitter.home_mixer.model.HomeFeatures.ScoreFeature
import com.twitter.home_mixer.param.HomeGlobalParams.EnableImpressionBloomFilter
import com.twitter.home_mixer.param.HomeMixerFlagName.TargetFetchLatency
import com.twitter.home_mixer.param.HomeMixerFlagName.TargetScoringLatency
import com.twitter.home_mixer.product.scored_tweets.candidate_pipeline.CachedScoredTweetsCandidatePipelineConfig
import com.twitter.home_mixer.product.scored_tweets.candidate_pipeline.ScoredTweetsBackfillCandidatePipelineConfig
import com.twitter.home_mixer.product.scored_tweets.candidate_pipeline.ScoredTweetsFrsCandidatePipelineConfig
import com.twitter.home_mixer.product.scored_tweets.candidate_pipeline.ScoredTweetsInNetworkCandidatePipelineConfig
import com.twitter.home_mixer.product.scored_tweets.candidate_pipeline.ScoredTweetsListsCandidatePipelineConfig
import com.twitter.home_mixer.product.scored_tweets.candidate_pipeline.ScoredTweetsPopularVideosCandidatePipelineConfig
import com.twitter.home_mixer.product.scored_tweets.candidate_pipeline.ScoredTweetsTweetMixerCandidatePipelineConfig
import com.twitter.home_mixer.product.scored_tweets.candidate_pipeline.ScoredTweetsUtegCandidatePipelineConfig
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.CachedScoredTweetsQueryFeatureHydrator
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.ListIdsQueryFeatureHydrator
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.RealGraphQueryFeatureHydrator
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.RealTimeInteractionGraphUserVertexQueryFeatureHydrator
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.RequestTimeQueryFeatureHydrator
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.TwhinUserEngagementQueryFeatureHydrator
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.TwhinUserFollowQueryFeatureHydrator
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.UserLanguagesFeatureHydrator
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.UserStateQueryFeatureHydrator
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.offline_aggregates.PartAAggregateQueryFeatureHydrator
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.offline_aggregates.PartBAggregateQueryFeatureHydrator
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.real_time_aggregates.UserEngagementRealTimeAggregatesFeatureHydrator
import com.twitter.home_mixer.product.scored_tweets.filter.DuplicateConversationTweetsFilter
import com.twitter.home_mixer.product.scored_tweets.filter.OutOfNetworkCompetitorFilter
import com.twitter.home_mixer.product.scored_tweets.filter.OutOfNetworkCompetitorURLFilter
import com.twitter.home_mixer.product.scored_tweets.filter.ScoredTweetsSocialContextFilter
import com.twitter.home_mixer.product.scored_tweets.marshaller.ScoredTweetsResponseDomainMarshaller
import com.twitter.home_mixer.product.scored_tweets.marshaller.ScoredTweetsResponseTransportMarshaller
import com.twitter.home_mixer.product.scored_tweets.model.ScoredTweetsQuery
import com.twitter.home_mixer.product.scored_tweets.model.ScoredTweetsResponse
import com.twitter.home_mixer.product.scored_tweets.param.ScoredTweetsParam.MaxInNetworkResultsParam
import com.twitter.home_mixer.product.scored_tweets.param.ScoredTweetsParam.MaxOutOfNetworkResultsParam
import com.twitter.home_mixer.product.scored_tweets.scoring_pipeline.ScoredTweetsHeuristicScoringPipelineConfig
import com.twitter.home_mixer.product.scored_tweets.scoring_pipeline.ScoredTweetsModelScoringPipelineConfig
import com.twitter.home_mixer.product.scored_tweets.selector.KeepBestOutOfNetworkCandidatePerAuthorPerSuggestType
import com.twitter.home_mixer.product.scored_tweets.side_effect.CachedScoredTweetsSideEffect
import com.twitter.home_mixer.product.scored_tweets.side_effect.ScribeScoredCandidatesSideEffect
import com.twitter.home_mixer.product.scored_tweets.side_effect.ScribeServedCommonFeaturesAndCandidateFeaturesSideEffect
import com.twitter.home_mixer.{thriftscala => t}
import com.twitter.inject.annotations.Flag
import com.twitter.product_mixer.component_library.feature_hydrator.query.async.AsyncQueryFeatureHydrator
import com.twitter.product_mixer.component_library.feature_hydrator.query.impressed_tweets.ImpressedTweetsQueryFeatureHydrator
import com.twitter.product_mixer.component_library.feature_hydrator.query.param_gated.ParamGatedQueryFeatureHydrator
import com.twitter.product_mixer.component_library.feature_hydrator.query.social_graph.SGSFollowedUsersQueryFeatureHydrator
import com.twitter.product_mixer.component_library.filter.PredicateFeatureFilter
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.component_library.selector.DropDuplicateCandidates
import com.twitter.product_mixer.component_library.selector.DropFilteredMaxCandidates
import com.twitter.product_mixer.component_library.selector.DropMaxCandidates
import com.twitter.product_mixer.component_library.selector.IdAndClassDuplicationKey
import com.twitter.product_mixer.component_library.selector.InsertAppendResults
import com.twitter.product_mixer.component_library.selector.PickFirstCandidateMerger
import com.twitter.product_mixer.component_library.selector.UpdateSortCandidates
import com.twitter.product_mixer.component_library.selector.sorter.FeatureValueSorter
import com.twitter.product_mixer.core.functional_component.common.AllExceptPipelines
import com.twitter.product_mixer.core.functional_component.common.AllPipelines
import com.twitter.product_mixer.core.functional_component.configapi.StaticParam
import com.twitter.product_mixer.core.functional_component.feature_hydrator.QueryFeatureHydrator
import com.twitter.product_mixer.core.functional_component.filter.Filter
import com.twitter.product_mixer.core.functional_component.marshaller.TransportMarshaller
import com.twitter.product_mixer.core.functional_component.premarshaller.DomainMarshaller
import com.twitter.product_mixer.core.functional_component.selector.Selector
import com.twitter.product_mixer.core.functional_component.side_effect.PipelineResultSideEffect
import com.twitter.product_mixer.core.model.common.identifier.CandidatePipelineIdentifier
import com.twitter.product_mixer.core.model.common.identifier.ComponentIdentifier
import com.twitter.product_mixer.core.model.common.identifier.FilterIdentifier
import com.twitter.product_mixer.core.model.common.identifier.RecommendationPipelineIdentifier
import com.twitter.product_mixer.core.model.common.identifier.ScoringPipelineIdentifier
import com.twitter.product_mixer.core.model.common.presentation.ItemCandidateWithDetails
import com.twitter.product_mixer.core.pipeline.FailOpenPolicy
import com.twitter.product_mixer.core.pipeline.candidate.CandidatePipelineConfig
import com.twitter.product_mixer.core.pipeline.recommendation.RecommendationPipelineConfig
import com.twitter.product_mixer.core.pipeline.scoring.ScoringPipelineConfig
import com.twitter.product_mixer.core.quality_factor.BoundsWithDefault
import com.twitter.product_mixer.core.quality_factor.LinearLatencyQualityFactorConfig
import com.twitter.product_mixer.core.quality_factor.QualityFactorConfig
import com.twitter.util.Duration
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class ScoredTweetsRecommendationPipelineConfig @Inject() (
scoredTweetsInNetworkCandidatePipelineConfig: ScoredTweetsInNetworkCandidatePipelineConfig,
scoredTweetsUtegCandidatePipelineConfig: ScoredTweetsUtegCandidatePipelineConfig,
scoredTweetsTweetMixerCandidatePipelineConfig: ScoredTweetsTweetMixerCandidatePipelineConfig,
scoredTweetsFrsCandidatePipelineConfig: ScoredTweetsFrsCandidatePipelineConfig,
scoredTweetsListsCandidatePipelineConfig: ScoredTweetsListsCandidatePipelineConfig,
scoredTweetsPopularVideosCandidatePipelineConfig: ScoredTweetsPopularVideosCandidatePipelineConfig,
scoredTweetsBackfillCandidatePipelineConfig: ScoredTweetsBackfillCandidatePipelineConfig,
cachedScoredTweetsCandidatePipelineConfig: CachedScoredTweetsCandidatePipelineConfig,
requestQueryFeatureHydrator: RequestQueryFeatureHydrator[ScoredTweetsQuery],
requestTimeQueryFeatureHydrator: RequestTimeQueryFeatureHydrator,
realTimeInteractionGraphUserVertexQueryFeatureHydrator: RealTimeInteractionGraphUserVertexQueryFeatureHydrator,
userStateQueryFeatureHydrator: UserStateQueryFeatureHydrator,
userEngagementRealTimeAggregatesFeatureHydrator: UserEngagementRealTimeAggregatesFeatureHydrator,
twhinUserEngagementQueryFeatureHydrator: TwhinUserEngagementQueryFeatureHydrator,
twhinUserFollowQueryFeatureHydrator: TwhinUserFollowQueryFeatureHydrator,
cachedScoredTweetsQueryFeatureHydrator: CachedScoredTweetsQueryFeatureHydrator,
sgsFollowedUsersQueryFeatureHydrator: SGSFollowedUsersQueryFeatureHydrator,
scoredTweetsModelScoringPipelineConfig: ScoredTweetsModelScoringPipelineConfig,
impressionBloomFilterQueryFeatureHydrator: ImpressionBloomFilterQueryFeatureHydrator[
ScoredTweetsQuery
],
manhattanTweetImpressionsQueryFeatureHydrator: TweetImpressionsQueryFeatureHydrator[
ScoredTweetsQuery
],
memcacheTweetImpressionsQueryFeatureHydrator: ImpressedTweetsQueryFeatureHydrator,
listIdsQueryFeatureHydrator: ListIdsQueryFeatureHydrator,
feedbackHistoryQueryFeatureHydrator: FeedbackHistoryQueryFeatureHydrator,
publishClientSentImpressionsEventBusSideEffect: PublishClientSentImpressionsEventBusSideEffect,
publishClientSentImpressionsManhattanSideEffect: PublishClientSentImpressionsManhattanSideEffect,
publishImpressionBloomFilterSideEffect: PublishImpressionBloomFilterSideEffect,
realGraphInNetworkScoresQueryFeatureHydrator: RealGraphInNetworkScoresQueryFeatureHydrator,
realGraphQueryFeatureHydrator: RealGraphQueryFeatureHydrator,
userLanguagesFeatureHydrator: UserLanguagesFeatureHydrator,
partAAggregateQueryFeatureHydrator: PartAAggregateQueryFeatureHydrator,
partBAggregateQueryFeatureHydrator: PartBAggregateQueryFeatureHydrator,
cachedScoredTweetsSideEffect: CachedScoredTweetsSideEffect,
scribeScoredCandidatesSideEffect: ScribeScoredCandidatesSideEffect,
scribeServedCommonFeaturesAndCandidateFeaturesSideEffect: ScribeServedCommonFeaturesAndCandidateFeaturesSideEffect,
updateLastNonPollingTimeSideEffect: UpdateLastNonPollingTimeSideEffect[
ScoredTweetsQuery,
ScoredTweetsResponse
],
@Flag(TargetFetchLatency) targetFetchLatency: Duration,
@Flag(TargetScoringLatency) targetScoringLatency: Duration)
extends RecommendationPipelineConfig[
ScoredTweetsQuery,
TweetCandidate,
ScoredTweetsResponse,
t.ScoredTweetsResponse
] {
override val identifier: RecommendationPipelineIdentifier =
RecommendationPipelineIdentifier("ScoredTweets")
private val SubscriptionReplyFilterId = "SubscriptionReply"
private val MaxBackfillTweets = 50
private val scoringStep = RecommendationPipelineConfig.scoringPipelinesStep
override val fetchQueryFeatures: Seq[QueryFeatureHydrator[ScoredTweetsQuery]] = Seq(
requestQueryFeatureHydrator,
realGraphInNetworkScoresQueryFeatureHydrator,
cachedScoredTweetsQueryFeatureHydrator,
sgsFollowedUsersQueryFeatureHydrator,
ParamGatedQueryFeatureHydrator(
EnableImpressionBloomFilter,
impressionBloomFilterQueryFeatureHydrator
),
manhattanTweetImpressionsQueryFeatureHydrator,
memcacheTweetImpressionsQueryFeatureHydrator,
listIdsQueryFeatureHydrator,
userStateQueryFeatureHydrator,
AsyncQueryFeatureHydrator(scoringStep, feedbackHistoryQueryFeatureHydrator),
AsyncQueryFeatureHydrator(scoringStep, realGraphQueryFeatureHydrator),
AsyncQueryFeatureHydrator(scoringStep, requestTimeQueryFeatureHydrator),
AsyncQueryFeatureHydrator(scoringStep, userLanguagesFeatureHydrator),
AsyncQueryFeatureHydrator(scoringStep, userEngagementRealTimeAggregatesFeatureHydrator),
AsyncQueryFeatureHydrator(scoringStep, realTimeInteractionGraphUserVertexQueryFeatureHydrator),
AsyncQueryFeatureHydrator(scoringStep, twhinUserFollowQueryFeatureHydrator),
AsyncQueryFeatureHydrator(scoringStep, twhinUserEngagementQueryFeatureHydrator),
AsyncQueryFeatureHydrator(scoringStep, partAAggregateQueryFeatureHydrator),
AsyncQueryFeatureHydrator(scoringStep, partBAggregateQueryFeatureHydrator),
)
override val candidatePipelines: Seq[
CandidatePipelineConfig[ScoredTweetsQuery, _, _, TweetCandidate]
] = Seq(
cachedScoredTweetsCandidatePipelineConfig,
scoredTweetsInNetworkCandidatePipelineConfig,
scoredTweetsUtegCandidatePipelineConfig,
scoredTweetsTweetMixerCandidatePipelineConfig,
scoredTweetsFrsCandidatePipelineConfig,
scoredTweetsListsCandidatePipelineConfig,
scoredTweetsPopularVideosCandidatePipelineConfig,
scoredTweetsBackfillCandidatePipelineConfig
)
override val postCandidatePipelinesSelectors: Seq[Selector[ScoredTweetsQuery]] = Seq(
DropDuplicateCandidates(
pipelineScope = AllPipelines,
duplicationKey = IdAndClassDuplicationKey,
mergeStrategy = PickFirstCandidateMerger
),
InsertAppendResults(AllPipelines)
)
override val globalFilters: Seq[Filter[ScoredTweetsQuery, TweetCandidate]] = Seq(
// sort these to have the "cheaper" filters run first
RejectTweetFromViewerFilter,
RetweetDeduplicationFilter,
PreviouslySeenTweetsFilter,
PreviouslyServedTweetsFilter,
PredicateFeatureFilter.fromPredicate(
FilterIdentifier(SubscriptionReplyFilterId),
shouldKeepCandidate = { features =>
features.getOrElse(InReplyToTweetIdFeature, None).isEmpty ||
features.getOrElse(ExclusiveConversationAuthorIdFeature, None).isEmpty
}
),
FeedbackFatigueFilter
)
override val candidatePipelineFailOpenPolicies: Map[CandidatePipelineIdentifier, FailOpenPolicy] =
Map(
cachedScoredTweetsCandidatePipelineConfig.identifier -> FailOpenPolicy.Always,
scoredTweetsInNetworkCandidatePipelineConfig.identifier -> FailOpenPolicy.Always,
scoredTweetsUtegCandidatePipelineConfig.identifier -> FailOpenPolicy.Always,
scoredTweetsTweetMixerCandidatePipelineConfig.identifier -> FailOpenPolicy.Always,
scoredTweetsFrsCandidatePipelineConfig.identifier -> FailOpenPolicy.Always,
scoredTweetsListsCandidatePipelineConfig.identifier -> FailOpenPolicy.Always,
scoredTweetsPopularVideosCandidatePipelineConfig.identifier -> FailOpenPolicy.Always,
scoredTweetsBackfillCandidatePipelineConfig.identifier -> FailOpenPolicy.Always
)
override val scoringPipelineFailOpenPolicies: Map[ScoringPipelineIdentifier, FailOpenPolicy] =
Map(
ScoredTweetsHeuristicScoringPipelineConfig.identifier -> FailOpenPolicy.Always
)
private val candidatePipelineQualityFactorConfig = LinearLatencyQualityFactorConfig(
qualityFactorBounds = BoundsWithDefault(minInclusive = 0.1, maxInclusive = 1.0, default = 0.95),
initialDelay = 60.seconds,
targetLatency = targetFetchLatency,
targetLatencyPercentile = 95.0,
delta = 0.00125
)
private val scoringPipelineQualityFactorConfig =
candidatePipelineQualityFactorConfig.copy(targetLatency = targetScoringLatency)
override val qualityFactorConfigs: Map[ComponentIdentifier, QualityFactorConfig] = Map(
// candidate pipelines
scoredTweetsInNetworkCandidatePipelineConfig.identifier -> candidatePipelineQualityFactorConfig,
scoredTweetsUtegCandidatePipelineConfig.identifier -> candidatePipelineQualityFactorConfig,
scoredTweetsTweetMixerCandidatePipelineConfig.identifier -> candidatePipelineQualityFactorConfig,
scoredTweetsFrsCandidatePipelineConfig.identifier -> candidatePipelineQualityFactorConfig,
scoredTweetsListsCandidatePipelineConfig.identifier -> candidatePipelineQualityFactorConfig,
scoredTweetsPopularVideosCandidatePipelineConfig.identifier -> candidatePipelineQualityFactorConfig,
scoredTweetsBackfillCandidatePipelineConfig.identifier -> candidatePipelineQualityFactorConfig,
// scoring pipelines
scoredTweetsModelScoringPipelineConfig.identifier -> scoringPipelineQualityFactorConfig,
)
override val scoringPipelines: Seq[ScoringPipelineConfig[ScoredTweetsQuery, TweetCandidate]] =
Seq(
// scoring pipeline - run on non-cached candidates only since cached ones are already scored
scoredTweetsModelScoringPipelineConfig,
// re-scoring pipeline - run on all candidates since these are request specific
ScoredTweetsHeuristicScoringPipelineConfig
)
override val postScoringFilters = Seq(
ScoredTweetsSocialContextFilter,
OutOfNetworkCompetitorFilter,
OutOfNetworkCompetitorURLFilter,
DuplicateConversationTweetsFilter,
PredicateFeatureFilter.fromPredicate(
FilterIdentifier("IsSupportAccountReply"),
shouldKeepCandidate = { features =>
!features.getOrElse(IsSupportAccountReplyFeature, false)
})
)
override val resultSelectors: Seq[Selector[ScoredTweetsQuery]] = Seq(
KeepBestOutOfNetworkCandidatePerAuthorPerSuggestType(AllPipelines),
UpdateSortCandidates(AllPipelines, FeatureValueSorter.descending(ScoreFeature)),
DropFilteredMaxCandidates(
pipelineScope =
AllExceptPipelines(Set(scoredTweetsBackfillCandidatePipelineConfig.identifier)),
filter = {
case ItemCandidateWithDetails(_, _, features) =>
features.getOrElse(InNetworkFeature, false)
case _ => false
},
maxSelectionsParam = MaxInNetworkResultsParam
),
DropFilteredMaxCandidates(
pipelineScope = AllPipelines,
filter = {
case ItemCandidateWithDetails(_, _, features) =>
!features.getOrElse(InNetworkFeature, false)
case _ => false
},
maxSelectionsParam = MaxOutOfNetworkResultsParam
),
DropMaxCandidates(
candidatePipeline = scoredTweetsBackfillCandidatePipelineConfig.identifier,
maxSelectionsParam = StaticParam(MaxBackfillTweets)
),
InsertAppendResults(AllPipelines)
)
override val resultSideEffects: Seq[
PipelineResultSideEffect[ScoredTweetsQuery, ScoredTweetsResponse]
] = Seq(
cachedScoredTweetsSideEffect,
publishClientSentImpressionsEventBusSideEffect,
publishClientSentImpressionsManhattanSideEffect,
publishImpressionBloomFilterSideEffect,
scribeScoredCandidatesSideEffect,
scribeServedCommonFeaturesAndCandidateFeaturesSideEffect,
updateLastNonPollingTimeSideEffect
)
override val domainMarshaller: DomainMarshaller[
ScoredTweetsQuery,
ScoredTweetsResponse
] = ScoredTweetsResponseDomainMarshaller
override val transportMarshaller: TransportMarshaller[
ScoredTweetsResponse,
t.ScoredTweetsResponse
] = ScoredTweetsResponseTransportMarshaller
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/candidate_pipeline/BUILD.bazel | scala_library(
sources = ["*.scala"],
compiler_option_sets = ["fatal_warnings"],
strict_deps = True,
tags = ["bazel-compatible"],
dependencies = [
"explore/explore-ranker/thrift/src/main/thrift:thrift-scala",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/functional_component/feature_hydrator",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/functional_component/filter",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/functional_component/gate",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/model",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/model/request",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/candidate_source",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/filter",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/gate",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/model",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/param",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/query_transformer",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/response_transformer",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/util",
"home-mixer/thrift/src/main/thrift:thrift-scala",
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/candidate_source/explore_ranker",
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/candidate_source/timeline_ranker",
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/candidate_source/tweet_mixer",
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/filter",
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/gate",
"product-mixer/core/src/main/scala/com/twitter/product_mixer/core/functional_component/marshaller/request",
"product-mixer/core/src/main/scala/com/twitter/product_mixer/core/pipeline/candidate",
"src/thrift/com/twitter/timelineranker:thrift-scala",
"tweet-mixer/thrift/src/main/thrift:thrift-scala",
],
exports = [
"src/thrift/com/twitter/timelineranker:thrift-scala",
"tweet-mixer/thrift/src/main/thrift:thrift-scala",
],
)
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/candidate_pipeline/CachedScoredTweetsCandidatePipelineConfig.scala | package com.twitter.home_mixer.product.scored_tweets.candidate_pipeline
import com.twitter.home_mixer.product.scored_tweets.candidate_pipeline.CachedScoredTweetsCandidatePipelineConfig._
import com.twitter.home_mixer.product.scored_tweets.candidate_source.CachedScoredTweetsCandidateSource
import com.twitter.home_mixer.product.scored_tweets.model.ScoredTweetsQuery
import com.twitter.home_mixer.product.scored_tweets.response_transformer.CachedScoredTweetsResponseFeatureTransformer
import com.twitter.home_mixer.{thriftscala => hmt}
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.functional_component.candidate_source.BaseCandidateSource
import com.twitter.product_mixer.core.functional_component.transformer.CandidateFeatureTransformer
import com.twitter.product_mixer.core.functional_component.transformer.CandidatePipelineQueryTransformer
import com.twitter.product_mixer.core.functional_component.transformer.CandidatePipelineResultsTransformer
import com.twitter.product_mixer.core.model.common.identifier.CandidatePipelineIdentifier
import com.twitter.product_mixer.core.pipeline.candidate.CandidatePipelineConfig
import javax.inject.Inject
import javax.inject.Singleton
/**
* Candidate Pipeline Config that fetches tweets from Scored Tweets Cache.
*/
@Singleton
class CachedScoredTweetsCandidatePipelineConfig @Inject() (
cachedScoredTweetsCandidateSource: CachedScoredTweetsCandidateSource)
extends CandidatePipelineConfig[
ScoredTweetsQuery,
ScoredTweetsQuery,
hmt.ScoredTweet,
TweetCandidate
] {
override val identifier: CandidatePipelineIdentifier = Identifier
override val queryTransformer: CandidatePipelineQueryTransformer[
ScoredTweetsQuery,
ScoredTweetsQuery
] = identity
override val candidateSource: BaseCandidateSource[ScoredTweetsQuery, hmt.ScoredTweet] =
cachedScoredTweetsCandidateSource
override val featuresFromCandidateSourceTransformers: Seq[
CandidateFeatureTransformer[hmt.ScoredTweet]
] = Seq(CachedScoredTweetsResponseFeatureTransformer)
override val resultTransformer: CandidatePipelineResultsTransformer[
hmt.ScoredTweet,
TweetCandidate
] = { sourceResult => TweetCandidate(id = sourceResult.tweetId) }
}
object CachedScoredTweetsCandidatePipelineConfig {
val Identifier: CandidatePipelineIdentifier = CandidatePipelineIdentifier("CachedScoredTweets")
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/candidate_pipeline/ScoredTweetsBackfillCandidatePipelineConfig.scala | package com.twitter.home_mixer.product.scored_tweets.candidate_pipeline
import com.twitter.home_mixer.functional_component.filter.ReplyFilter
import com.twitter.home_mixer.model.HomeFeatures.AuthorIdFeature
import com.twitter.home_mixer.model.HomeFeatures.TimelineServiceTweetsFeature
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.TweetypieStaticEntitiesFeatureHydrator
import com.twitter.home_mixer.product.scored_tweets.gate.MinCachedTweetsGate
import com.twitter.home_mixer.product.scored_tweets.gate.MinTimeSinceLastRequestGate
import com.twitter.home_mixer.product.scored_tweets.model.ScoredTweetsQuery
import com.twitter.home_mixer.product.scored_tweets.param.ScoredTweetsParam.CachedScoredTweets
import com.twitter.home_mixer.product.scored_tweets.param.ScoredTweetsParam.CandidatePipeline
import com.twitter.home_mixer.product.scored_tweets.param.ScoredTweetsParam.EnableBackfillCandidatePipelineParam
import com.twitter.home_mixer.product.scored_tweets.response_transformer.ScoredTweetsBackfillResponseFeatureTransformer
import com.twitter.product_mixer.component_library.filter.PredicateFeatureFilter
import com.twitter.product_mixer.component_library.gate.NonEmptySeqFeatureGate
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.functional_component.candidate_source.CandidateSource
import com.twitter.product_mixer.core.functional_component.candidate_source.PassthroughCandidateSource
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BaseCandidateFeatureHydrator
import com.twitter.product_mixer.core.functional_component.filter.Filter
import com.twitter.product_mixer.core.functional_component.gate.Gate
import com.twitter.product_mixer.core.functional_component.transformer.CandidateFeatureTransformer
import com.twitter.product_mixer.core.functional_component.transformer.CandidatePipelineQueryTransformer
import com.twitter.product_mixer.core.functional_component.transformer.CandidatePipelineResultsTransformer
import com.twitter.product_mixer.core.model.common.identifier.CandidatePipelineIdentifier
import com.twitter.product_mixer.core.model.common.identifier.CandidateSourceIdentifier
import com.twitter.product_mixer.core.model.common.identifier.FilterIdentifier
import com.twitter.product_mixer.core.pipeline.candidate.CandidatePipelineConfig
import com.twitter.timelines.configapi.FSParam
import com.twitter.timelines.configapi.decider.DeciderParam
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class ScoredTweetsBackfillCandidatePipelineConfig @Inject() (
tweetypieStaticEntitiesHydrator: TweetypieStaticEntitiesFeatureHydrator)
extends CandidatePipelineConfig[
ScoredTweetsQuery,
ScoredTweetsQuery,
Long,
TweetCandidate
] {
override val identifier: CandidatePipelineIdentifier =
CandidatePipelineIdentifier("ScoredTweetsBackfill")
private val HasAuthorFilterId = "HasAuthor"
override val enabledDeciderParam: Option[DeciderParam[Boolean]] =
Some(CandidatePipeline.EnableBackfillParam)
override val supportedClientParam: Option[FSParam[Boolean]] =
Some(EnableBackfillCandidatePipelineParam)
override val gates: Seq[Gate[ScoredTweetsQuery]] =
Seq(
MinTimeSinceLastRequestGate,
NonEmptySeqFeatureGate(TimelineServiceTweetsFeature),
MinCachedTweetsGate(identifier, CachedScoredTweets.MinCachedTweetsParam)
)
override val queryTransformer: CandidatePipelineQueryTransformer[
ScoredTweetsQuery,
ScoredTweetsQuery
] = identity
override def candidateSource: CandidateSource[ScoredTweetsQuery, Long] =
PassthroughCandidateSource(
identifier = CandidateSourceIdentifier("ScoredTweetsBackfill"),
candidateExtractor = { query =>
query.features.map(_.getOrElse(TimelineServiceTweetsFeature, Seq.empty)).toSeq.flatten
}
)
override val featuresFromCandidateSourceTransformers: Seq[
CandidateFeatureTransformer[Long]
] = Seq(ScoredTweetsBackfillResponseFeatureTransformer)
override val resultTransformer: CandidatePipelineResultsTransformer[Long, TweetCandidate] = {
sourceResult => TweetCandidate(id = sourceResult)
}
override val preFilterFeatureHydrationPhase1: Seq[
BaseCandidateFeatureHydrator[ScoredTweetsQuery, TweetCandidate, _]
] = Seq(tweetypieStaticEntitiesHydrator)
override val filters: Seq[Filter[ScoredTweetsQuery, TweetCandidate]] = Seq(
ReplyFilter,
PredicateFeatureFilter.fromPredicate(
FilterIdentifier(HasAuthorFilterId),
shouldKeepCandidate = _.getOrElse(AuthorIdFeature, None).isDefined
)
)
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/candidate_pipeline/ScoredTweetsFrsCandidatePipelineConfig.scala | package com.twitter.home_mixer.product.scored_tweets.candidate_pipeline
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.FrsSeedUsersQueryFeatureHydrator
import com.twitter.home_mixer.product.scored_tweets.gate.MinCachedTweetsGate
import com.twitter.home_mixer.product.scored_tweets.model.ScoredTweetsQuery
import com.twitter.home_mixer.product.scored_tweets.param.ScoredTweetsParam.CachedScoredTweets
import com.twitter.home_mixer.product.scored_tweets.param.ScoredTweetsParam.CandidatePipeline
import com.twitter.home_mixer.product.scored_tweets.query_transformer.TimelineRankerFrsQueryTransformer
import com.twitter.home_mixer.product.scored_tweets.response_transformer.ScoredTweetsFrsResponseFeatureTransformer
import com.twitter.product_mixer.component_library.candidate_source.timeline_ranker.TimelineRankerRecapCandidateSource
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.functional_component.candidate_source.BaseCandidateSource
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BaseQueryFeatureHydrator
import com.twitter.product_mixer.core.functional_component.gate.Gate
import com.twitter.product_mixer.core.functional_component.transformer.CandidateFeatureTransformer
import com.twitter.product_mixer.core.functional_component.transformer.CandidatePipelineQueryTransformer
import com.twitter.product_mixer.core.functional_component.transformer.CandidatePipelineResultsTransformer
import com.twitter.product_mixer.core.model.common.identifier.CandidatePipelineIdentifier
import com.twitter.product_mixer.core.pipeline.candidate.CandidatePipelineConfig
import com.twitter.timelineranker.{thriftscala => tlr}
import com.twitter.timelines.configapi.decider.DeciderParam
import javax.inject.Inject
import javax.inject.Singleton
/**
* Candidate Pipeline Config that takes user recommendations from Follow Recommendation Service (FRS)
* and makes a TimelineRanker->Earlybird query for tweet candidates from those users.
* Additionally, the candidate pipeline hydrates followedByUserIds so that followed-by social proof
* can be used.
*/
@Singleton
class ScoredTweetsFrsCandidatePipelineConfig @Inject() (
timelineRankerRecapCandidateSource: TimelineRankerRecapCandidateSource,
frsSeedUsersQueryFeatureHydrator: FrsSeedUsersQueryFeatureHydrator)
extends CandidatePipelineConfig[
ScoredTweetsQuery,
tlr.RecapQuery,
tlr.CandidateTweet,
TweetCandidate
] {
override val identifier: CandidatePipelineIdentifier =
CandidatePipelineIdentifier("ScoredTweetsFrs")
override val enabledDeciderParam: Option[DeciderParam[Boolean]] =
Some(CandidatePipeline.EnableFrsParam)
override val gates: Seq[Gate[ScoredTweetsQuery]] = Seq(
MinCachedTweetsGate(identifier, CachedScoredTweets.MinCachedTweetsParam)
)
override val queryFeatureHydration: Seq[
BaseQueryFeatureHydrator[ScoredTweetsQuery, _]
] = Seq(frsSeedUsersQueryFeatureHydrator)
override val candidateSource: BaseCandidateSource[tlr.RecapQuery, tlr.CandidateTweet] =
timelineRankerRecapCandidateSource
override val queryTransformer: CandidatePipelineQueryTransformer[
ScoredTweetsQuery,
tlr.RecapQuery
] = TimelineRankerFrsQueryTransformer(identifier)
override val featuresFromCandidateSourceTransformers: Seq[
CandidateFeatureTransformer[tlr.CandidateTweet]
] = Seq(ScoredTweetsFrsResponseFeatureTransformer)
override val resultTransformer: CandidatePipelineResultsTransformer[
tlr.CandidateTweet,
TweetCandidate
] = { candidate => TweetCandidate(candidate.tweet.get.id) }
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/candidate_pipeline/ScoredTweetsInNetworkCandidatePipelineConfig.scala | package com.twitter.home_mixer.product.scored_tweets.candidate_pipeline
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.IsExtendedReplyFeatureHydrator
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.ReplyFeatureHydrator
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.RetweetSourceTweetFeatureHydrator
import com.twitter.home_mixer.product.scored_tweets.filter.RetweetSourceTweetRemovingFilter
import com.twitter.home_mixer.product.scored_tweets.gate.MinCachedTweetsGate
import com.twitter.home_mixer.product.scored_tweets.model.ScoredTweetsQuery
import com.twitter.home_mixer.product.scored_tweets.param.ScoredTweetsParam.CachedScoredTweets
import com.twitter.home_mixer.product.scored_tweets.param.ScoredTweetsParam.CandidatePipeline
import com.twitter.home_mixer.product.scored_tweets.query_transformer.TimelineRankerInNetworkQueryTransformer
import com.twitter.home_mixer.product.scored_tweets.response_transformer.ScoredTweetsInNetworkResponseFeatureTransformer
import com.twitter.product_mixer.component_library.candidate_source.timeline_ranker.TimelineRankerInNetworkCandidateSource
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.functional_component.candidate_source.BaseCandidateSource
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BaseCandidateFeatureHydrator
import com.twitter.product_mixer.core.functional_component.filter.Filter
import com.twitter.product_mixer.core.functional_component.gate.Gate
import com.twitter.product_mixer.core.functional_component.transformer.CandidateFeatureTransformer
import com.twitter.product_mixer.core.functional_component.transformer.CandidatePipelineQueryTransformer
import com.twitter.product_mixer.core.functional_component.transformer.CandidatePipelineResultsTransformer
import com.twitter.product_mixer.core.model.common.identifier.CandidatePipelineIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.pipeline.candidate.CandidatePipelineConfig
import com.twitter.timelineranker.{thriftscala => t}
import com.twitter.timelines.configapi.decider.DeciderParam
import javax.inject.Inject
import javax.inject.Singleton
/**
* Candidate Pipeline Config to fetch in-network tweets from Timeline Ranker's Recycled source
*/
@Singleton
class ScoredTweetsInNetworkCandidatePipelineConfig @Inject() (
timelineRankerInNetworkCandidateSource: TimelineRankerInNetworkCandidateSource,
replyFeatureHydrator: ReplyFeatureHydrator)
extends CandidatePipelineConfig[
ScoredTweetsQuery,
t.RecapQuery,
t.CandidateTweet,
TweetCandidate
] {
override val identifier: CandidatePipelineIdentifier =
CandidatePipelineIdentifier("ScoredTweetsInNetwork")
override val enabledDeciderParam: Option[DeciderParam[Boolean]] =
Some(CandidatePipeline.EnableInNetworkParam)
override val gates: Seq[Gate[ScoredTweetsQuery]] = Seq(
MinCachedTweetsGate(identifier, CachedScoredTweets.MinCachedTweetsParam)
)
override val candidateSource: BaseCandidateSource[t.RecapQuery, t.CandidateTweet] =
timelineRankerInNetworkCandidateSource
override val queryTransformer: CandidatePipelineQueryTransformer[
ScoredTweetsQuery,
t.RecapQuery
] = TimelineRankerInNetworkQueryTransformer(identifier)
override val preFilterFeatureHydrationPhase1: Seq[
BaseCandidateFeatureHydrator[PipelineQuery, TweetCandidate, _]
] = Seq(RetweetSourceTweetFeatureHydrator)
override def filters: Seq[Filter[ScoredTweetsQuery, TweetCandidate]] = Seq(
RetweetSourceTweetRemovingFilter
)
override val postFilterFeatureHydration: Seq[
BaseCandidateFeatureHydrator[PipelineQuery, TweetCandidate, _]
] = Seq(IsExtendedReplyFeatureHydrator, replyFeatureHydrator)
override val featuresFromCandidateSourceTransformers: Seq[
CandidateFeatureTransformer[t.CandidateTweet]
] = Seq(ScoredTweetsInNetworkResponseFeatureTransformer)
override val resultTransformer: CandidatePipelineResultsTransformer[
t.CandidateTweet,
TweetCandidate
] = { sourceResult => TweetCandidate(id = sourceResult.tweet.get.id) }
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/candidate_pipeline/ScoredTweetsListsCandidatePipelineConfig.scala | package com.twitter.home_mixer.product.scored_tweets.candidate_pipeline
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.TweetypieStaticEntitiesFeatureHydrator
import com.twitter.home_mixer.functional_component.filter.ReplyFilter
import com.twitter.home_mixer.functional_component.filter.RetweetFilter
import com.twitter.home_mixer.product.scored_tweets.candidate_source.ListsCandidateSource
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.ListIdsFeature
import com.twitter.home_mixer.product.scored_tweets.gate.MinCachedTweetsGate
import com.twitter.home_mixer.product.scored_tweets.model.ScoredTweetsQuery
import com.twitter.home_mixer.product.scored_tweets.param.ScoredTweetsParam.CachedScoredTweets
import com.twitter.home_mixer.product.scored_tweets.param.ScoredTweetsParam.CandidatePipeline
import com.twitter.home_mixer.product.scored_tweets.response_transformer.ScoredTweetsListsResponseFeatureTransformer
import com.twitter.product_mixer.component_library.gate.NonEmptySeqFeatureGate
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.functional_component.candidate_source.CandidateSource
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BaseCandidateFeatureHydrator
import com.twitter.product_mixer.core.functional_component.filter.Filter
import com.twitter.product_mixer.core.functional_component.gate.Gate
import com.twitter.product_mixer.core.functional_component.transformer.CandidateFeatureTransformer
import com.twitter.product_mixer.core.functional_component.transformer.CandidatePipelineQueryTransformer
import com.twitter.product_mixer.core.functional_component.transformer.CandidatePipelineResultsTransformer
import com.twitter.product_mixer.core.model.common.identifier.CandidatePipelineIdentifier
import com.twitter.product_mixer.core.pipeline.candidate.CandidatePipelineConfig
import com.twitter.timelines.configapi.decider.DeciderParam
import com.twitter.timelineservice.{thriftscala => t}
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class ScoredTweetsListsCandidatePipelineConfig @Inject() (
listsCandidateSource: ListsCandidateSource,
tweetypieStaticEntitiesHydrator: TweetypieStaticEntitiesFeatureHydrator)
extends CandidatePipelineConfig[
ScoredTweetsQuery,
Seq[t.TimelineQuery],
t.Tweet,
TweetCandidate
] {
override val identifier: CandidatePipelineIdentifier =
CandidatePipelineIdentifier("ScoredTweetsLists")
private val MaxTweetsToFetchPerList = 20
override val enabledDeciderParam: Option[DeciderParam[Boolean]] =
Some(CandidatePipeline.EnableListsParam)
override val gates: Seq[Gate[ScoredTweetsQuery]] = Seq(
NonEmptySeqFeatureGate(ListIdsFeature),
MinCachedTweetsGate(identifier, CachedScoredTweets.MinCachedTweetsParam)
)
override val queryTransformer: CandidatePipelineQueryTransformer[
ScoredTweetsQuery,
Seq[t.TimelineQuery]
] = { query =>
val listIds = query.features.map(_.get(ListIdsFeature)).get
listIds.map { listId =>
t.TimelineQuery(
timelineType = t.TimelineType.List,
timelineId = listId,
maxCount = MaxTweetsToFetchPerList.toShort,
options = Some(t.TimelineQueryOptions(query.clientContext.userId)),
timelineId2 = Some(t.TimelineId(t.TimelineType.List, listId, None))
)
}
}
override def candidateSource: CandidateSource[Seq[t.TimelineQuery], t.Tweet] =
listsCandidateSource
override val featuresFromCandidateSourceTransformers: Seq[
CandidateFeatureTransformer[t.Tweet]
] = Seq(ScoredTweetsListsResponseFeatureTransformer)
override val resultTransformer: CandidatePipelineResultsTransformer[t.Tweet, TweetCandidate] = {
sourceResult => TweetCandidate(id = sourceResult.statusId)
}
override val preFilterFeatureHydrationPhase1: Seq[
BaseCandidateFeatureHydrator[ScoredTweetsQuery, TweetCandidate, _]
] = Seq(tweetypieStaticEntitiesHydrator)
override val filters: Seq[Filter[ScoredTweetsQuery, TweetCandidate]] =
Seq(ReplyFilter, RetweetFilter)
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/candidate_pipeline/ScoredTweetsPopularVideosCandidatePipelineConfig.scala | package com.twitter.home_mixer.product.scored_tweets.candidate_pipeline
import com.twitter.explore_ranker.{thriftscala => ert}
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.TweetypieStaticEntitiesFeatureHydrator
import com.twitter.home_mixer.product.scored_tweets.gate.MinCachedTweetsGate
import com.twitter.home_mixer.product.scored_tweets.model.ScoredTweetsQuery
import com.twitter.home_mixer.product.scored_tweets.param.ScoredTweetsParam.CachedScoredTweets
import com.twitter.home_mixer.product.scored_tweets.param.ScoredTweetsParam.CandidatePipeline
import com.twitter.home_mixer.product.scored_tweets.response_transformer.ScoredTweetsPopularVideosResponseFeatureTransformer
import com.twitter.home_mixer.util.CachedScoredTweetsHelper
import com.twitter.product_mixer.component_library.candidate_source.explore_ranker.ExploreRankerImmersiveRecsCandidateSource
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.functional_component.candidate_source.BaseCandidateSource
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BaseCandidateFeatureHydrator
import com.twitter.product_mixer.core.functional_component.gate.Gate
import com.twitter.product_mixer.core.functional_component.marshaller.request.ClientContextMarshaller
import com.twitter.product_mixer.core.functional_component.transformer.CandidateFeatureTransformer
import com.twitter.product_mixer.core.functional_component.transformer.CandidatePipelineQueryTransformer
import com.twitter.product_mixer.core.functional_component.transformer.CandidatePipelineResultsTransformer
import com.twitter.product_mixer.core.model.common.identifier.CandidatePipelineIdentifier
import com.twitter.product_mixer.core.pipeline.candidate.CandidatePipelineConfig
import com.twitter.timelines.configapi.decider.DeciderParam
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class ScoredTweetsPopularVideosCandidatePipelineConfig @Inject() (
exploreRankerCandidateSource: ExploreRankerImmersiveRecsCandidateSource,
tweetypieStaticEntitiesFeatureHydrator: TweetypieStaticEntitiesFeatureHydrator)
extends CandidatePipelineConfig[
ScoredTweetsQuery,
ert.ExploreRankerRequest,
ert.ExploreTweetRecommendation,
TweetCandidate
] {
override val identifier: CandidatePipelineIdentifier =
CandidatePipelineIdentifier("ScoredTweetsPopularVideos")
private val MaxTweetsToFetch = 40
override val enabledDeciderParam: Option[DeciderParam[Boolean]] =
Some(CandidatePipeline.EnablePopularVideosParam)
override val gates: Seq[Gate[ScoredTweetsQuery]] = Seq(
MinCachedTweetsGate(identifier, CachedScoredTweets.MinCachedTweetsParam)
)
override val queryTransformer: CandidatePipelineQueryTransformer[
ScoredTweetsQuery,
ert.ExploreRankerRequest
] = { query =>
val excludedTweetIds = query.features.map(
CachedScoredTweetsHelper.tweetImpressionsAndCachedScoredTweets(_, identifier))
ert.ExploreRankerRequest(
clientContext = ClientContextMarshaller(query.clientContext),
product = ert.Product.HomeTimelineVideoInline,
productContext = Some(
ert.ProductContext.HomeTimelineVideoInline(ert.HomeTimelineVideoInline(excludedTweetIds))),
maxResults = Some(MaxTweetsToFetch)
)
}
override def candidateSource: BaseCandidateSource[
ert.ExploreRankerRequest,
ert.ExploreTweetRecommendation
] = exploreRankerCandidateSource
override val featuresFromCandidateSourceTransformers: Seq[
CandidateFeatureTransformer[ert.ExploreTweetRecommendation]
] = Seq(ScoredTweetsPopularVideosResponseFeatureTransformer)
override val resultTransformer: CandidatePipelineResultsTransformer[
ert.ExploreTweetRecommendation,
TweetCandidate
] = { sourceResult => TweetCandidate(id = sourceResult.tweetId) }
override val preFilterFeatureHydrationPhase1: Seq[
BaseCandidateFeatureHydrator[ScoredTweetsQuery, TweetCandidate, _]
] = Seq(tweetypieStaticEntitiesFeatureHydrator)
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/candidate_pipeline/ScoredTweetsTweetMixerCandidatePipelineConfig.scala | package com.twitter.home_mixer.product.scored_tweets.candidate_pipeline
import com.twitter.tweet_mixer.{thriftscala => t}
import com.twitter.home_mixer.model.HomeFeatures.AuthorIdFeature
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.TweetypieStaticEntitiesFeatureHydrator
import com.twitter.home_mixer.product.scored_tweets.gate.MinCachedTweetsGate
import com.twitter.home_mixer.product.scored_tweets.model.ScoredTweetsQuery
import com.twitter.home_mixer.product.scored_tweets.param.ScoredTweetsParam.CachedScoredTweets
import com.twitter.home_mixer.product.scored_tweets.param.ScoredTweetsParam.CandidatePipeline
import com.twitter.home_mixer.product.scored_tweets.response_transformer.ScoredTweetsTweetMixerResponseFeatureTransformer
import com.twitter.home_mixer.util.CachedScoredTweetsHelper
import com.twitter.product_mixer.component_library.candidate_source.tweet_mixer.TweetMixerCandidateSource
import com.twitter.product_mixer.component_library.filter.PredicateFeatureFilter
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.functional_component.candidate_source.BaseCandidateSource
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BaseCandidateFeatureHydrator
import com.twitter.product_mixer.core.functional_component.filter.Filter
import com.twitter.product_mixer.core.functional_component.gate.Gate
import com.twitter.product_mixer.core.functional_component.marshaller.request.ClientContextMarshaller
import com.twitter.product_mixer.core.functional_component.transformer.CandidateFeatureTransformer
import com.twitter.product_mixer.core.functional_component.transformer.CandidatePipelineQueryTransformer
import com.twitter.product_mixer.core.functional_component.transformer.CandidatePipelineResultsTransformer
import com.twitter.product_mixer.core.model.common.identifier.CandidatePipelineIdentifier
import com.twitter.product_mixer.core.model.common.identifier.FilterIdentifier
import com.twitter.product_mixer.core.pipeline.candidate.CandidatePipelineConfig
import com.twitter.timelines.configapi.decider.DeciderParam
import javax.inject.Inject
import javax.inject.Singleton
/**
* Candidate Pipeline Config that fetches tweets from TweetMixer.
*/
@Singleton
class ScoredTweetsTweetMixerCandidatePipelineConfig @Inject() (
tweetMixerCandidateSource: TweetMixerCandidateSource,
tweetypieStaticEntitiesFeatureHydrator: TweetypieStaticEntitiesFeatureHydrator)
extends CandidatePipelineConfig[
ScoredTweetsQuery,
t.TweetMixerRequest,
t.TweetResult,
TweetCandidate
] {
override val identifier: CandidatePipelineIdentifier =
CandidatePipelineIdentifier("ScoredTweetsTweetMixer")
val HasAuthorFilterId = "HasAuthor"
override val enabledDeciderParam: Option[DeciderParam[Boolean]] =
Some(CandidatePipeline.EnableTweetMixerParam)
override val gates: Seq[Gate[ScoredTweetsQuery]] = Seq(
MinCachedTweetsGate(identifier, CachedScoredTweets.MinCachedTweetsParam),
)
override val candidateSource: BaseCandidateSource[t.TweetMixerRequest, t.TweetResult] =
tweetMixerCandidateSource
private val MaxTweetsToFetch = 400
override val queryTransformer: CandidatePipelineQueryTransformer[
ScoredTweetsQuery,
t.TweetMixerRequest
] = { query =>
val maxCount = (query.getQualityFactorCurrentValue(identifier) * MaxTweetsToFetch).toInt
val excludedTweetIds = query.features.map(
CachedScoredTweetsHelper.tweetImpressionsAndCachedScoredTweets(_, identifier))
t.TweetMixerRequest(
clientContext = ClientContextMarshaller(query.clientContext),
product = t.Product.HomeRecommendedTweets,
productContext = Some(
t.ProductContext.HomeRecommendedTweetsProductContext(
t.HomeRecommendedTweetsProductContext(excludedTweetIds = excludedTweetIds.map(_.toSet)))),
maxResults = Some(maxCount)
)
}
override val preFilterFeatureHydrationPhase1: Seq[
BaseCandidateFeatureHydrator[ScoredTweetsQuery, TweetCandidate, _]
] = Seq(tweetypieStaticEntitiesFeatureHydrator)
override val featuresFromCandidateSourceTransformers: Seq[
CandidateFeatureTransformer[t.TweetResult]
] = Seq(ScoredTweetsTweetMixerResponseFeatureTransformer)
override val filters: Seq[Filter[ScoredTweetsQuery, TweetCandidate]] = Seq(
PredicateFeatureFilter.fromPredicate(
FilterIdentifier(HasAuthorFilterId),
shouldKeepCandidate = _.getOrElse(AuthorIdFeature, None).isDefined
)
)
override val resultTransformer: CandidatePipelineResultsTransformer[
t.TweetResult,
TweetCandidate
] = { sourceResult => TweetCandidate(id = sourceResult.tweetId) }
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/candidate_pipeline/ScoredTweetsUtegCandidatePipelineConfig.scala | package com.twitter.home_mixer.product.scored_tweets.candidate_pipeline
import com.twitter.home_mixer.product.scored_tweets.gate.MinCachedTweetsGate
import com.twitter.home_mixer.product.scored_tweets.model.ScoredTweetsQuery
import com.twitter.home_mixer.product.scored_tweets.param.ScoredTweetsParam.CachedScoredTweets
import com.twitter.home_mixer.product.scored_tweets.param.ScoredTweetsParam.CandidatePipeline
import com.twitter.home_mixer.product.scored_tweets.query_transformer.TimelineRankerUtegQueryTransformer
import com.twitter.home_mixer.product.scored_tweets.response_transformer.ScoredTweetsUtegResponseFeatureTransformer
import com.twitter.product_mixer.component_library.candidate_source.timeline_ranker.TimelineRankerUtegCandidateSource
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.functional_component.candidate_source.BaseCandidateSource
import com.twitter.product_mixer.core.functional_component.gate.Gate
import com.twitter.product_mixer.core.functional_component.transformer.CandidateFeatureTransformer
import com.twitter.product_mixer.core.functional_component.transformer.CandidatePipelineQueryTransformer
import com.twitter.product_mixer.core.functional_component.transformer.CandidatePipelineResultsTransformer
import com.twitter.product_mixer.core.model.common.identifier.CandidatePipelineIdentifier
import com.twitter.product_mixer.core.pipeline.candidate.CandidatePipelineConfig
import com.twitter.timelineranker.{thriftscala => t}
import com.twitter.timelines.configapi.decider.DeciderParam
import javax.inject.Inject
import javax.inject.Singleton
/**
* Candidate Pipeline Config that fetches tweets from the Timeline Ranker UTEG Candidate Source
*/
@Singleton
class ScoredTweetsUtegCandidatePipelineConfig @Inject() (
timelineRankerUtegCandidateSource: TimelineRankerUtegCandidateSource)
extends CandidatePipelineConfig[
ScoredTweetsQuery,
t.UtegLikedByTweetsQuery,
t.CandidateTweet,
TweetCandidate
] {
override val identifier: CandidatePipelineIdentifier =
CandidatePipelineIdentifier("ScoredTweetsUteg")
override val enabledDeciderParam: Option[DeciderParam[Boolean]] =
Some(CandidatePipeline.EnableUtegParam)
override val gates: Seq[Gate[ScoredTweetsQuery]] = Seq(
MinCachedTweetsGate(identifier, CachedScoredTweets.MinCachedTweetsParam)
)
override val candidateSource: BaseCandidateSource[t.UtegLikedByTweetsQuery, t.CandidateTweet] =
timelineRankerUtegCandidateSource
override val queryTransformer: CandidatePipelineQueryTransformer[
ScoredTweetsQuery,
t.UtegLikedByTweetsQuery
] = TimelineRankerUtegQueryTransformer(identifier)
override val featuresFromCandidateSourceTransformers: Seq[
CandidateFeatureTransformer[t.CandidateTweet]
] = Seq(ScoredTweetsUtegResponseFeatureTransformer)
override val resultTransformer: CandidatePipelineResultsTransformer[
t.CandidateTweet,
TweetCandidate
] = { sourceResult => TweetCandidate(id = sourceResult.tweet.get.id) }
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/candidate_pipeline/earlybird/BUILD.bazel | scala_library(
sources = ["*.scala"],
compiler_option_sets = ["fatal_warnings"],
strict_deps = True,
tags = ["bazel-compatible"],
dependencies = [
"home-mixer/server/src/main/scala/com/twitter/home_mixer/functional_component/candidate_source",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/model/request",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/candidate_source",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/gate",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/model",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/param",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/query_transformer/earlybird",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/response_transformer/earlybird",
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/candidate_source/earlybird",
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/filter",
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/gate",
"src/thrift/com/twitter/search:earlybird-scala",
],
)
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/candidate_pipeline/earlybird/ScoredTweetsEarlybirdFrsCandidatePipelineConfig.scala | package com.twitter.home_mixer.product.scored_tweets.candidate_pipeline.earlybird
import com.twitter.finagle.thrift.ClientId
import com.twitter.home_mixer.functional_component.candidate_source.EarlybirdCandidateSource
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.FrsSeedUsersQueryFeatureHydrator
import com.twitter.home_mixer.product.scored_tweets.gate.MinCachedTweetsGate
import com.twitter.home_mixer.product.scored_tweets.model.ScoredTweetsQuery
import com.twitter.home_mixer.product.scored_tweets.param.ScoredTweetsParam.CachedScoredTweets
import com.twitter.home_mixer.product.scored_tweets.query_transformer.earlybird.EarlybirdFrsQueryTransformer
import com.twitter.home_mixer.product.scored_tweets.response_transformer.earlybird.ScoredTweetsEarlybirdFrsResponseFeatureTransformer
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.functional_component.candidate_source.BaseCandidateSource
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BaseQueryFeatureHydrator
import com.twitter.product_mixer.core.functional_component.filter.Filter
import com.twitter.product_mixer.core.functional_component.gate.Gate
import com.twitter.product_mixer.core.functional_component.transformer.CandidateFeatureTransformer
import com.twitter.product_mixer.core.functional_component.transformer.CandidatePipelineQueryTransformer
import com.twitter.product_mixer.core.functional_component.transformer.CandidatePipelineResultsTransformer
import com.twitter.product_mixer.core.model.common.identifier.CandidatePipelineIdentifier
import com.twitter.product_mixer.core.pipeline.candidate.CandidatePipelineConfig
import com.twitter.search.earlybird.{thriftscala => eb}
import javax.inject.Inject
import javax.inject.Singleton
/**
* Candidate Pipeline Config that fetches tweets from the earlybird FRS Candidate Source
*/
@Singleton
class ScoredTweetsEarlybirdFrsCandidatePipelineConfig @Inject() (
earlybirdCandidateSource: EarlybirdCandidateSource,
frsSeedUsersQueryFeatureHydrator: FrsSeedUsersQueryFeatureHydrator,
clientId: ClientId)
extends CandidatePipelineConfig[
ScoredTweetsQuery,
eb.EarlybirdRequest,
eb.ThriftSearchResult,
TweetCandidate
] {
override val identifier: CandidatePipelineIdentifier =
CandidatePipelineIdentifier("ScoredTweetsEarlybirdFrs")
override val gates: Seq[Gate[ScoredTweetsQuery]] = Seq(
MinCachedTweetsGate(identifier, CachedScoredTweets.MinCachedTweetsParam)
)
override val queryFeatureHydration: Seq[
BaseQueryFeatureHydrator[ScoredTweetsQuery, _]
] = Seq(frsSeedUsersQueryFeatureHydrator)
override val candidateSource: BaseCandidateSource[eb.EarlybirdRequest, eb.ThriftSearchResult] =
earlybirdCandidateSource
override val queryTransformer: CandidatePipelineQueryTransformer[
ScoredTweetsQuery,
eb.EarlybirdRequest
] = EarlybirdFrsQueryTransformer(identifier, clientId = Some(clientId.name))
override val featuresFromCandidateSourceTransformers: Seq[
CandidateFeatureTransformer[eb.ThriftSearchResult]
] = Seq(ScoredTweetsEarlybirdFrsResponseFeatureTransformer)
override val resultTransformer: CandidatePipelineResultsTransformer[
eb.ThriftSearchResult,
TweetCandidate
] = { sourceResult => TweetCandidate(id = sourceResult.id) }
override def filters: Seq[Filter[ScoredTweetsQuery, TweetCandidate]] = Seq.empty
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/candidate_pipeline/earlybird/ScoredTweetsEarlybirdInNetworkCandidatePipelineConfig.scala | package com.twitter.home_mixer.product.scored_tweets.candidate_pipeline.earlybird
import com.twitter.finagle.thrift.ClientId
import com.twitter.home_mixer.functional_component.candidate_source.EarlybirdCandidateSource
import com.twitter.home_mixer.product.scored_tweets.gate.MinCachedTweetsGate
import com.twitter.home_mixer.product.scored_tweets.model.ScoredTweetsQuery
import com.twitter.home_mixer.product.scored_tweets.param.ScoredTweetsParam.CachedScoredTweets
import com.twitter.home_mixer.product.scored_tweets.query_transformer.earlybird.EarlybirdInNetworkQueryTransformer
import com.twitter.home_mixer.product.scored_tweets.response_transformer.earlybird.ScoredTweetsEarlybirdInNetworkResponseFeatureTransformer
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.functional_component.candidate_source.BaseCandidateSource
import com.twitter.product_mixer.core.functional_component.gate.Gate
import com.twitter.product_mixer.core.functional_component.transformer.CandidateFeatureTransformer
import com.twitter.product_mixer.core.functional_component.transformer.CandidatePipelineQueryTransformer
import com.twitter.product_mixer.core.functional_component.transformer.CandidatePipelineResultsTransformer
import com.twitter.product_mixer.core.model.common.identifier.CandidatePipelineIdentifier
import com.twitter.product_mixer.core.pipeline.candidate.CandidatePipelineConfig
import com.twitter.search.earlybird.{thriftscala => eb}
import javax.inject.Inject
import javax.inject.Singleton
/**
* Candidate Pipeline Config that fetches tweets from the earlybird InNetwork Candidate Source
*/
@Singleton
class ScoredTweetsEarlybirdInNetworkCandidatePipelineConfig @Inject() (
earlybirdCandidateSource: EarlybirdCandidateSource,
clientId: ClientId)
extends CandidatePipelineConfig[
ScoredTweetsQuery,
eb.EarlybirdRequest,
eb.ThriftSearchResult,
TweetCandidate
] {
override val identifier: CandidatePipelineIdentifier =
CandidatePipelineIdentifier("ScoredTweetsEarlybirdInNetwork")
override val gates: Seq[Gate[ScoredTweetsQuery]] = Seq(
MinCachedTweetsGate(identifier, CachedScoredTweets.MinCachedTweetsParam)
)
override val candidateSource: BaseCandidateSource[eb.EarlybirdRequest, eb.ThriftSearchResult] =
earlybirdCandidateSource
override val queryTransformer: CandidatePipelineQueryTransformer[
ScoredTweetsQuery,
eb.EarlybirdRequest
] = EarlybirdInNetworkQueryTransformer(identifier, clientId = Some(clientId.name))
override val featuresFromCandidateSourceTransformers: Seq[
CandidateFeatureTransformer[eb.ThriftSearchResult]
] = Seq(ScoredTweetsEarlybirdInNetworkResponseFeatureTransformer)
override val resultTransformer: CandidatePipelineResultsTransformer[
eb.ThriftSearchResult,
TweetCandidate
] = { sourceResult => TweetCandidate(id = sourceResult.id) }
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/candidate_source/BUILD.bazel | scala_library(
sources = ["*.scala"],
compiler_option_sets = ["fatal_warnings"],
strict_deps = True,
tags = ["bazel-compatible"],
dependencies = [
"home-mixer/server/src/main/scala/com/twitter/home_mixer/util",
"home-mixer/thrift/src/main/thrift:thrift-scala",
"product-mixer/core/src/main/scala/com/twitter/product_mixer/core/product",
"src/thrift/com/twitter/timelineservice:thrift-scala",
"stitch/stitch-timelineservice",
],
)
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/candidate_source/CachedScoredTweetsCandidateSource.scala | package com.twitter.home_mixer.product.scored_tweets.candidate_source
import com.twitter.home_mixer.util.CachedScoredTweetsHelper
import com.twitter.home_mixer.{thriftscala => hmt}
import com.twitter.product_mixer.core.functional_component.candidate_source.CandidateSource
import com.twitter.product_mixer.core.model.common.identifier.CandidateSourceIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.stitch.Stitch
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class CachedScoredTweetsCandidateSource @Inject() ()
extends CandidateSource[PipelineQuery, hmt.ScoredTweet] {
override val identifier: CandidateSourceIdentifier =
CandidateSourceIdentifier("CachedScoredTweets")
override def apply(request: PipelineQuery): Stitch[Seq[hmt.ScoredTweet]] = {
Stitch.value(
request.features.map(CachedScoredTweetsHelper.unseenCachedScoredTweets).getOrElse(Seq.empty))
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/candidate_source/ListsCandidateSource.scala | package com.twitter.home_mixer.product.scored_tweets.candidate_source
import com.twitter.product_mixer.core.functional_component.candidate_source.CandidateSource
import com.twitter.product_mixer.core.model.common.identifier.CandidateSourceIdentifier
import com.twitter.stitch.Stitch
import com.twitter.stitch.timelineservice.TimelineService
import com.twitter.timelineservice.{thriftscala => tls}
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class ListsCandidateSource @Inject() (timelineService: TimelineService)
extends CandidateSource[Seq[tls.TimelineQuery], tls.Tweet] {
override val identifier: CandidateSourceIdentifier = CandidateSourceIdentifier("Lists")
override def apply(requests: Seq[tls.TimelineQuery]): Stitch[Seq[tls.Tweet]] = {
val timelines = Stitch.traverse(requests) { request => timelineService.getTimeline(request) }
timelines.map {
_.flatMap {
_.entries.collect { case tls.TimelineEntry.Tweet(tweet) => tweet }
}
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/AncestorFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.home_mixer.model.HomeFeatures.AncestorsFeature
import com.twitter.home_mixer.model.HomeFeatures.InReplyToTweetIdFeature
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.CandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.util.OffloadFuturePools
import com.twitter.stitch.Stitch
import com.twitter.tweetconvosvc.tweet_ancestor.{thriftscala => ta}
import com.twitter.tweetconvosvc.{thriftscala => tcs}
import com.twitter.util.Future
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class AncestorFeatureHydrator @Inject() (
conversationServiceClient: tcs.ConversationService.MethodPerEndpoint)
extends CandidateFeatureHydrator[PipelineQuery, TweetCandidate] {
override val identifier: FeatureHydratorIdentifier = FeatureHydratorIdentifier("Ancestor")
override val features: Set[Feature[_, _]] = Set(AncestorsFeature)
private val DefaultFeatureMap = FeatureMapBuilder().add(AncestorsFeature, Seq.empty).build()
override def apply(
query: PipelineQuery,
candidate: TweetCandidate,
existingFeatures: FeatureMap
): Stitch[FeatureMap] = OffloadFuturePools.offloadFuture {
if (existingFeatures.getOrElse(InReplyToTweetIdFeature, None).isDefined) {
val ancestorsRequest = tcs.GetAncestorsRequest(Seq(candidate.id))
conversationServiceClient.getAncestors(ancestorsRequest).map { getAncestorsResponse =>
val ancestors = getAncestorsResponse.ancestors.headOption
.collect {
case tcs.TweetAncestorsResult.TweetAncestors(ancestorsResult)
if ancestorsResult.nonEmpty =>
ancestorsResult.head.ancestors ++ getTruncatedRootTweet(ancestorsResult.head)
}.getOrElse(Seq.empty)
FeatureMapBuilder().add(AncestorsFeature, ancestors).build()
}
} else Future.value(DefaultFeatureMap)
}
private def getTruncatedRootTweet(
ancestors: ta.TweetAncestors,
): Option[ta.TweetAncestor] = {
ancestors.conversationRootAuthorId.collect {
case rootAuthorId
if ancestors.state == ta.ReplyState.Partial &&
ancestors.ancestors.last.tweetId != ancestors.conversationId =>
ta.TweetAncestor(ancestors.conversationId, rootAuthorId)
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/AuthorFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.finagle.stats.StatsReceiver
import com.twitter.home_mixer.param.HomeMixerInjectionNames.AuthorFeatureRepository
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.adapters.author_features.AuthorFeaturesAdapter
import com.twitter.home_mixer.util.CandidatesUtil
import com.twitter.home_mixer.util.ObservedKeyValueResultHandler
import com.twitter.ml.api.DataRecord
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BulkCandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.util.OffloadFuturePools
import com.twitter.servo.repository.KeyValueRepository
import com.twitter.servo.repository.KeyValueResult
import com.twitter.stitch.Stitch
import com.twitter.timelines.author_features.v1.{thriftjava => af}
import com.twitter.util.Future
import com.twitter.util.Try
import javax.inject.Inject
import javax.inject.Named
import javax.inject.Singleton
import scala.collection.JavaConverters._
object AuthorFeature
extends DataRecordInAFeature[TweetCandidate]
with FeatureWithDefaultOnFailure[TweetCandidate, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
@Singleton
class AuthorFeatureHydrator @Inject() (
@Named(AuthorFeatureRepository) client: KeyValueRepository[Seq[Long], Long, af.AuthorFeatures],
override val statsReceiver: StatsReceiver)
extends BulkCandidateFeatureHydrator[PipelineQuery, TweetCandidate]
with ObservedKeyValueResultHandler {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("AuthorFeature")
override val features: Set[Feature[_, _]] = Set(AuthorFeature)
override val statScope: String = identifier.toString
override def apply(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Stitch[Seq[FeatureMap]] = OffloadFuturePools.offloadFuture {
val possiblyAuthorIds = extractKeys(candidates)
val authorIds = possiblyAuthorIds.flatten
val response: Future[KeyValueResult[Long, af.AuthorFeatures]] =
if (authorIds.nonEmpty) client(authorIds)
else Future.value(KeyValueResult.empty)
response.map { result =>
possiblyAuthorIds.map { possiblyAuthorId =>
val value = observedGet(key = possiblyAuthorId, keyValueResult = result)
val transformedValue = postTransformer(value)
FeatureMapBuilder().add(AuthorFeature, transformedValue).build()
}
}
}
private def postTransformer(authorFeatures: Try[Option[af.AuthorFeatures]]): Try[DataRecord] = {
authorFeatures.map {
_.map { features => AuthorFeaturesAdapter.adaptToDataRecords(features).asScala.head }
.getOrElse(new DataRecord())
}
}
private def extractKeys(
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Seq[Option[Long]] = {
candidates.map { candidate =>
CandidatesUtil.getOriginalAuthorId(candidate.features)
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/AuthorIsCreatorFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.finagle.stats.StatsReceiver
import com.twitter.home_mixer.model.HomeFeatures.AuthorIdFeature
import com.twitter.home_mixer.model.HomeFeatures.AuthorIsCreatorFeature
import com.twitter.home_mixer.util.MissingKeyException
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BulkCandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.util.OffloadFuturePools
import com.twitter.stitch.Stitch
import com.twitter.strato.generated.client.audiencerewards.audienceRewardsService.GetSuperFollowEligibilityOnUserClientColumn
import com.twitter.util.Throw
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class AuthorIsCreatorFeatureHydrator @Inject() (
getSuperFollowEligibilityOnUserClientColumn: GetSuperFollowEligibilityOnUserClientColumn,
statsReceiver: StatsReceiver)
extends BulkCandidateFeatureHydrator[PipelineQuery, TweetCandidate] {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("AuthorIsCreator")
override val features: Set[Feature[_, _]] =
Set(AuthorIsCreatorFeature)
private val scopedStatsReceiver = statsReceiver.scope(getClass.getSimpleName)
private val keyFoundCounter = scopedStatsReceiver.counter("key/found")
private val keyFailureCounter = scopedStatsReceiver.counter("key/failure")
private val MissingKeyFeatureMap = FeatureMapBuilder()
.add(AuthorIsCreatorFeature, Throw(MissingKeyException))
.build()
private val DefaultFeatureMap = FeatureMapBuilder()
.add(AuthorIsCreatorFeature, false)
.build()
override def apply(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Stitch[Seq[FeatureMap]] = {
OffloadFuturePools.offloadStitch {
val authorIds = candidates.flatMap(_.features.getOrElse(AuthorIdFeature, None)).distinct
Stitch
.collect {
authorIds.map { authorId =>
getSuperFollowEligibilityOnUserClientColumn.fetcher
.fetch(authorId)
.map { authorId -> _.v }
}
}.map { authorIdsToIsCreator =>
val authorIdsToIsCreatorMap = authorIdsToIsCreator.toMap
candidates.map { candidate =>
candidate.features.getOrElse(AuthorIdFeature, None) match {
case Some(authorId) =>
authorIdsToIsCreatorMap.get(authorId) match {
case Some(response) =>
keyFoundCounter.incr()
FeatureMapBuilder()
.add(AuthorIsCreatorFeature, response.getOrElse(false)).build()
case _ =>
keyFailureCounter.incr()
DefaultFeatureMap
}
case _ => MissingKeyFeatureMap
}
}
}
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/BUILD.bazel | scala_library(
sources = ["*.scala"],
compiler_option_sets = ["fatal_warnings"],
strict_deps = True,
tags = ["bazel-compatible"],
dependencies = [
"follow-recommendations-service/thrift/src/main/thrift:thrift-scala",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/functional_component/feature_hydrator",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/model",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/model/request",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/param",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/author_features",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/content",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/earlybird",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/inferred_topic",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/twhin_embeddings",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/model",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/param",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/service",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/util",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/util/earlybird",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/util/tweetypie",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/util/tweetypie/content",
"home-mixer/thrift/src/main/thrift:thrift-scala",
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/candidate_source/recommendations",
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/candidate_source/timeline_ranker",
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/feature_hydrator/query/social_graph",
"product-mixer/core/src/main/scala/com/twitter/product_mixer/core/functional_component/candidate_source/strato",
"product-mixer/core/src/main/scala/com/twitter/product_mixer/core/functional_component/feature_hydrator",
"product-mixer/core/src/main/scala/com/twitter/product_mixer/core/pipeline/candidate",
"product-mixer/core/src/main/scala/com/twitter/product_mixer/core/util",
"representation-scorer/server/src/main/scala/com/twitter/representationscorer/common",
"servo/repo/src/main/scala",
"servo/util/src/main/scala",
"snowflake/src/main/scala/com/twitter/snowflake/id",
"src/java/com/twitter/ml/api/constant",
"src/scala/com/twitter/ml/api/util",
"src/scala/com/twitter/timelines/prediction/adapters/conversation_features",
"src/scala/com/twitter/timelines/prediction/adapters/real_graph",
"src/scala/com/twitter/timelines/prediction/adapters/realtime_interaction_graph",
"src/scala/com/twitter/timelines/prediction/adapters/twistly",
"src/scala/com/twitter/timelines/prediction/adapters/two_hop_features",
"src/scala/com/twitter/timelines/prediction/common/adapters",
"src/scala/com/twitter/timelines/prediction/common/util",
"src/scala/com/twitter/timelines/prediction/features/common",
"src/scala/com/twitter/timelines/prediction/features/realtime_interaction_graph",
"src/scala/com/twitter/timelines/prediction/features/time_features",
"src/thrift/com/twitter/ml/api:data-java",
"src/thrift/com/twitter/onboarding/relevance/features:features-java",
"src/thrift/com/twitter/recos/user_tweet_entity_graph:user_tweet_entity_graph-scala",
"src/thrift/com/twitter/search:earlybird-scala",
"src/thrift/com/twitter/timelineranker:thrift-scala",
"src/thrift/com/twitter/timelines/author_features:thrift-java",
"stitch/stitch-gizmoduck",
"stitch/stitch-socialgraph",
"stitch/stitch-tweetypie",
"strato/config/columns/audiencerewards/audienceRewardsService:getSuperFollowEligibility-strato-client",
"strato/config/columns/ml/featureStore:featureStore-strato-client",
"timelines/src/main/scala/com/twitter/timelines/clients/strato/topics",
"timelines/src/main/scala/com/twitter/timelines/clients/strato/twistly",
"timelines/src/main/scala/com/twitter/timelines/common/model",
"timelines/src/main/scala/com/twitter/timelines/earlybird/common/utils",
"timelines/src/main/scala/com/twitter/timelines/model/candidate",
"timelines/src/main/scala/com/twitter/timelines/model/types",
"topic-social-proof/server/src/main/thrift:thrift-scala",
"topiclisting/topiclisting-core/src/main/scala/com/twitter/topiclisting",
"tweetconvosvc/thrift/src/main/thrift:thrift-scala",
"user_session_store/src/main/scala/com/twitter/user_session_store",
],
)
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/CachedScoredTweetsQueryFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.home_mixer.model.HomeFeatures._
import com.twitter.home_mixer.product.scored_tweets.param.ScoredTweetsParam.CachedScoredTweets
import com.twitter.home_mixer.{thriftscala => hmt}
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.QueryFeatureHydrator
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.servo.cache.TtlCache
import com.twitter.stitch.Stitch
import com.twitter.util.Return
import com.twitter.util.Throw
import com.twitter.util.Time
import javax.inject.Inject
import javax.inject.Singleton
/**
* Fetch scored Tweets from cache and exclude the expired ones
*/
@Singleton
case class CachedScoredTweetsQueryFeatureHydrator @Inject() (
scoredTweetsCache: TtlCache[Long, hmt.ScoredTweetsResponse])
extends QueryFeatureHydrator[PipelineQuery] {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("CachedScoredTweets")
override val features: Set[Feature[_, _]] = Set(CachedScoredTweetsFeature)
override def hydrate(query: PipelineQuery): Stitch[FeatureMap] = {
val userId = query.getRequiredUserId
val tweetScoreTtl = query.params(CachedScoredTweets.TTLParam)
Stitch.callFuture(scoredTweetsCache.get(Seq(userId))).map { keyValueResult =>
keyValueResult(userId) match {
case Return(cachedCandidatesOpt) =>
val cachedScoredTweets = cachedCandidatesOpt.map(_.scoredTweets).getOrElse(Seq.empty)
val nonExpiredTweets = cachedScoredTweets.filter { tweet =>
tweet.lastScoredTimestampMs.exists(Time.fromMilliseconds(_).untilNow < tweetScoreTtl)
}
FeatureMapBuilder().add(CachedScoredTweetsFeature, nonExpiredTweets).build()
case Throw(exception) => throw exception
}
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/EarlybirdFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.finagle.stats.StatsReceiver
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.adapters.earlybird.EarlybirdAdapter
import com.twitter.home_mixer.model.HomeFeatures.DeviceLanguageFeature
import com.twitter.home_mixer.model.HomeFeatures.EarlybirdFeature
import com.twitter.home_mixer.model.HomeFeatures.EarlybirdSearchResultFeature
import com.twitter.home_mixer.model.HomeFeatures.IsRetweetFeature
import com.twitter.home_mixer.model.HomeFeatures.TweetUrlsFeature
import com.twitter.home_mixer.model.HomeFeatures.UserScreenNameFeature
import com.twitter.home_mixer.param.HomeMixerInjectionNames.EarlybirdRepository
import com.twitter.home_mixer.util.ObservedKeyValueResultHandler
import com.twitter.home_mixer.util.earlybird.EarlybirdResponseUtil
import com.twitter.ml.api.DataRecord
import com.twitter.product_mixer.component_library.feature_hydrator.query.social_graph.SGSFollowedUsersFeature
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BulkCandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.util.OffloadFuturePools
import com.twitter.search.earlybird.{thriftscala => eb}
import com.twitter.servo.keyvalue.KeyValueResult
import com.twitter.servo.repository.KeyValueRepository
import com.twitter.stitch.Stitch
import com.twitter.util.Return
import javax.inject.Inject
import javax.inject.Named
import javax.inject.Singleton
import scala.collection.JavaConverters._
object EarlybirdDataRecordFeature
extends DataRecordInAFeature[TweetCandidate]
with FeatureWithDefaultOnFailure[TweetCandidate, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
@Singleton
class EarlybirdFeatureHydrator @Inject() (
@Named(EarlybirdRepository) client: KeyValueRepository[
(Seq[Long], Long),
Long,
eb.ThriftSearchResult
],
override val statsReceiver: StatsReceiver)
extends BulkCandidateFeatureHydrator[PipelineQuery, TweetCandidate]
with ObservedKeyValueResultHandler {
override val identifier: FeatureHydratorIdentifier = FeatureHydratorIdentifier("Earlybird")
override val features: Set[Feature[_, _]] = Set(
EarlybirdDataRecordFeature,
EarlybirdFeature,
EarlybirdSearchResultFeature,
TweetUrlsFeature
)
override val statScope: String = identifier.toString
private val scopedStatsReceiver = statsReceiver.scope(statScope)
private val originalKeyFoundCounter = scopedStatsReceiver.counter("originalKey/found")
private val originalKeyLossCounter = scopedStatsReceiver.counter("originalKey/loss")
private val ebSearchResultNotExistPredicate: CandidateWithFeatures[TweetCandidate] => Boolean =
candidate => candidate.features.getOrElse(EarlybirdSearchResultFeature, None).isEmpty
private val ebFeaturesNotExistPredicate: CandidateWithFeatures[TweetCandidate] => Boolean =
candidate => candidate.features.getOrElse(EarlybirdFeature, None).isEmpty
override def apply(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Stitch[Seq[FeatureMap]] = OffloadFuturePools.offloadFuture {
val candidatesToHydrate = candidates.filter { candidate =>
val isEmpty =
ebFeaturesNotExistPredicate(candidate) && ebSearchResultNotExistPredicate(candidate)
if (isEmpty) originalKeyLossCounter.incr() else originalKeyFoundCounter.incr()
isEmpty
}
client((candidatesToHydrate.map(_.candidate.id), query.getRequiredUserId))
.map(handleResponse(query, candidates, _, candidatesToHydrate))
}
private def handleResponse(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]],
results: KeyValueResult[Long, eb.ThriftSearchResult],
candidatesToHydrate: Seq[CandidateWithFeatures[TweetCandidate]]
): Seq[FeatureMap] = {
val queryFeatureMap = query.features.getOrElse(FeatureMap.empty)
val userLanguages = queryFeatureMap.getOrElse(UserLanguagesFeature, Seq.empty)
val uiLanguageCode = queryFeatureMap.getOrElse(DeviceLanguageFeature, None)
val screenName = queryFeatureMap.getOrElse(UserScreenNameFeature, None)
val followedUserIds = queryFeatureMap.getOrElse(SGSFollowedUsersFeature, Seq.empty).toSet
val searchResults = candidatesToHydrate
.map { candidate =>
observedGet(Some(candidate.candidate.id), results)
}.collect {
case Return(Some(value)) => value
}
val allSearchResults = searchResults ++
candidates.filter(!ebSearchResultNotExistPredicate(_)).flatMap { candidate =>
candidate.features
.getOrElse(EarlybirdSearchResultFeature, None)
}
val idToSearchResults = allSearchResults.map(sr => sr.id -> sr).toMap
val tweetIdToEbFeatures = EarlybirdResponseUtil.getTweetThriftFeaturesByTweetId(
searcherUserId = query.getRequiredUserId,
screenName = screenName,
userLanguages = userLanguages,
uiLanguageCode = uiLanguageCode,
followedUserIds = followedUserIds,
mutuallyFollowingUserIds = Set.empty,
searchResults = allSearchResults,
sourceTweetSearchResults = Seq.empty,
)
candidates.map { candidate =>
val transformedEbFeatures = tweetIdToEbFeatures.get(candidate.candidate.id)
val earlybirdFeatures =
if (transformedEbFeatures.nonEmpty) transformedEbFeatures
else candidate.features.getOrElse(EarlybirdFeature, None)
val candidateIsRetweet = candidate.features.getOrElse(IsRetweetFeature, false)
val sourceTweetEbFeatures =
candidate.features.getOrElse(SourceTweetEarlybirdFeature, None)
val originalTweetEbFeatures =
if (candidateIsRetweet && sourceTweetEbFeatures.nonEmpty)
sourceTweetEbFeatures
else earlybirdFeatures
val earlybirdDataRecord =
EarlybirdAdapter.adaptToDataRecords(originalTweetEbFeatures).asScala.head
FeatureMapBuilder()
.add(EarlybirdFeature, earlybirdFeatures)
.add(EarlybirdDataRecordFeature, earlybirdDataRecord)
.add(EarlybirdSearchResultFeature, idToSearchResults.get(candidate.candidate.id))
.add(TweetUrlsFeature, earlybirdFeatures.flatMap(_.urlsList).getOrElse(Seq.empty))
.build()
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/FrsSeedUsersQueryFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.follow_recommendations.{thriftscala => frs}
import com.twitter.home_mixer.product.scored_tweets.model.ScoredTweetsQuery
import com.twitter.product_mixer.component_library.candidate_source.recommendations.UserFollowRecommendationsCandidateSource
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.candidate_source.strato.StratoKeyView
import com.twitter.product_mixer.core.functional_component.feature_hydrator.QueryFeatureHydrator
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.stitch.Stitch
import javax.inject.Inject
import javax.inject.Singleton
object FrsSeedUserIdsFeature extends Feature[TweetCandidate, Option[Seq[Long]]]
object FrsUserToFollowedByUserIdsFeature extends Feature[TweetCandidate, Map[Long, Seq[Long]]]
@Singleton
case class FrsSeedUsersQueryFeatureHydrator @Inject() (
userFollowRecommendationsCandidateSource: UserFollowRecommendationsCandidateSource)
extends QueryFeatureHydrator[ScoredTweetsQuery] {
private val maxUsersToFetch = 100
override val identifier: FeatureHydratorIdentifier = FeatureHydratorIdentifier("FrsSeedUsers")
override def features: Set[Feature[_, _]] = Set(
FrsSeedUserIdsFeature,
FrsUserToFollowedByUserIdsFeature
)
override def hydrate(query: ScoredTweetsQuery): Stitch[FeatureMap] = {
val frsRequest = frs.RecommendationRequest(
clientContext = frs.ClientContext(query.getOptionalUserId),
displayLocation = frs.DisplayLocation.HomeTimelineTweetRecs,
maxResults = Some(maxUsersToFetch)
)
userFollowRecommendationsCandidateSource(StratoKeyView(frsRequest, Unit))
.map { userRecommendations: Seq[frs.UserRecommendation] =>
val seedUserIds = userRecommendations.map(_.userId)
val seedUserIdsSet = seedUserIds.toSet
val userToFollowedByUserIds: Map[Long, Seq[Long]] = userRecommendations.flatMap {
userRecommendation =>
if (seedUserIdsSet.contains(userRecommendation.userId)) {
val followProof =
userRecommendation.reason.flatMap(_.accountProof).flatMap(_.followProof)
val followedByUserIds = followProof.map(_.userIds).getOrElse(Seq.empty)
Some(userRecommendation.userId -> followedByUserIds)
} else {
None
}
}.toMap
FeatureMapBuilder()
.add(FrsSeedUserIdsFeature, Some(seedUserIds))
.add(FrsUserToFollowedByUserIdsFeature, userToFollowedByUserIds)
.build()
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/GizmoduckAuthorFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.conversions.DurationOps._
import com.twitter.ads.entities.db.{thriftscala => ae}
import com.twitter.gizmoduck.{thriftscala => gt}
import com.twitter.home_mixer.model.HomeFeatures.AuthorIdFeature
import com.twitter.home_mixer.model.HomeFeatures.AuthorIsBlueVerifiedFeature
import com.twitter.home_mixer.model.HomeFeatures.AuthorIsProtectedFeature
import com.twitter.home_mixer.model.HomeFeatures.FromInNetworkSourceFeature
import com.twitter.home_mixer.model.HomeFeatures.InReplyToTweetIdFeature
import com.twitter.home_mixer.model.HomeFeatures.IsRetweetFeature
import com.twitter.home_mixer.model.HomeFeatures.IsSupportAccountReplyFeature
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BulkCandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.util.OffloadFuturePools
import com.twitter.stitch.Stitch
import com.twitter.snowflake.id.SnowflakeId
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class GizmoduckAuthorFeatureHydrator @Inject() (gizmoduck: gt.UserService.MethodPerEndpoint)
extends BulkCandidateFeatureHydrator[PipelineQuery, TweetCandidate] {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("GizmoduckAuthor")
override val features: Set[Feature[_, _]] =
Set(AuthorIsBlueVerifiedFeature, AuthorIsProtectedFeature, IsSupportAccountReplyFeature)
private val queryFields: Set[gt.QueryFields] =
Set(gt.QueryFields.AdvertiserAccount, gt.QueryFields.Profile, gt.QueryFields.Safety)
override def apply(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Stitch[Seq[FeatureMap]] = OffloadFuturePools.offloadFuture {
val authorIds = candidates.flatMap(_.features.getOrElse(AuthorIdFeature, None))
val response = gizmoduck.get(
userIds = authorIds.distinct,
queryFields = queryFields,
context = gt.LookupContext()
)
response.map { hydratedAuthors =>
val userMetadataMap = hydratedAuthors
.collect {
case userResult if userResult.user.isDefined =>
val user = userResult.user.get
val blueVerified = user.safety.flatMap(_.isBlueVerified).getOrElse(false)
val isProtected = user.safety.exists(_.isProtected)
(user.id, (blueVerified, isProtected))
}.toMap.withDefaultValue((false, false))
candidates.map { candidate =>
val authorId = candidate.features.get(AuthorIdFeature).get
val (isBlueVerified, isProtected) = userMetadataMap(authorId)
// Some accounts run promotions on Twitter and send replies automatically.
// We assume that a reply that took more than one minute is not an auto-reply.
// If time difference doesn't exist, this means that one of the tweets was
// not snowflake and therefore much older, and therefore OK as an extended reply.
val timeDifference = candidate.features.getOrElse(InReplyToTweetIdFeature, None).map {
SnowflakeId.timeFromId(candidate.candidate.id) - SnowflakeId.timeFromId(_)
}
val isAutoReply = timeDifference.exists(_ < 1.minute)
FeatureMapBuilder()
.add(AuthorIsBlueVerifiedFeature, isBlueVerified)
.add(AuthorIsProtectedFeature, isProtected)
.add(IsSupportAccountReplyFeature, isAutoReply)
.build()
}
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/GraphTwoHopFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.finagle.stats.StatsReceiver
import com.twitter.graph_feature_service.{thriftscala => gfs}
import com.twitter.home_mixer.model.HomeFeatures.FollowedByUserIdsFeature
import com.twitter.home_mixer.model.HomeFeatures.FromInNetworkSourceFeature
import com.twitter.home_mixer.model.HomeFeatures.IsRetweetFeature
import com.twitter.home_mixer.param.HomeMixerInjectionNames.GraphTwoHopRepository
import com.twitter.home_mixer.util.CandidatesUtil
import com.twitter.home_mixer.util.ObservedKeyValueResultHandler
import com.twitter.ml.api.DataRecord
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BulkCandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.util.OffloadFuturePools
import com.twitter.servo.repository.KeyValueRepository
import com.twitter.stitch.Stitch
import com.twitter.timelines.prediction.adapters.two_hop_features.TwoHopFeaturesAdapter
import com.twitter.util.Try
import javax.inject.Inject
import javax.inject.Named
import javax.inject.Singleton
import scala.collection.JavaConverters._
object GraphTwoHopFeature
extends DataRecordInAFeature[TweetCandidate]
with FeatureWithDefaultOnFailure[TweetCandidate, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
@Singleton
class GraphTwoHopFeatureHydrator @Inject() (
@Named(GraphTwoHopRepository) client: KeyValueRepository[(Seq[Long], Long), Long, Seq[
gfs.IntersectionValue
]],
override val statsReceiver: StatsReceiver)
extends BulkCandidateFeatureHydrator[PipelineQuery, TweetCandidate]
with ObservedKeyValueResultHandler {
override val identifier: FeatureHydratorIdentifier = FeatureHydratorIdentifier("GraphTwoHop")
override val features: Set[Feature[_, _]] = Set(GraphTwoHopFeature, FollowedByUserIdsFeature)
override val statScope: String = identifier.toString
private val twoHopFeaturesAdapter = new TwoHopFeaturesAdapter
private val FollowFeatureType = gfs.FeatureType(gfs.EdgeType.Following, gfs.EdgeType.FollowedBy)
override def apply(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Stitch[Seq[FeatureMap]] = OffloadFuturePools.offloadFuture {
// Apply filters to in network candidates for retweets only.
val (inNetworkCandidates, oonCandidates) = candidates.partition { candidate =>
candidate.features.getOrElse(FromInNetworkSourceFeature, false)
}
val inNetworkCandidatesToHydrate =
inNetworkCandidates.filter(_.features.getOrElse(IsRetweetFeature, false))
val candidatesToHydrate = (inNetworkCandidatesToHydrate ++ oonCandidates)
.flatMap(candidate => CandidatesUtil.getOriginalAuthorId(candidate.features)).distinct
val response = client((candidatesToHydrate, query.getRequiredUserId))
response.map { result =>
candidates.map { candidate =>
val originalAuthorId = CandidatesUtil.getOriginalAuthorId(candidate.features)
val value = observedGet(key = originalAuthorId, keyValueResult = result)
val transformedValue = postTransformer(value)
val followedByUserIds = value.toOption
.flatMap(getFollowedByUserIds(_))
.getOrElse(Seq.empty)
FeatureMapBuilder()
.add(GraphTwoHopFeature, transformedValue)
.add(FollowedByUserIdsFeature, followedByUserIds)
.build()
}
}
}
private def getFollowedByUserIds(input: Option[Seq[gfs.IntersectionValue]]): Option[Seq[Long]] =
input.map(_.filter(_.featureType == FollowFeatureType).flatMap(_.intersectionIds).flatten)
private def postTransformer(input: Try[Option[Seq[gfs.IntersectionValue]]]): Try[DataRecord] =
input.map(twoHopFeaturesAdapter.adaptToDataRecords(_).asScala.head)
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/IsExtendedReplyFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.home_mixer.model.HomeFeatures.InReplyToTweetIdFeature
import com.twitter.home_mixer.model.HomeFeatures.InReplyToUserIdFeature
import com.twitter.home_mixer.model.HomeFeatures.IsExtendedReplyFeature
import com.twitter.home_mixer.model.HomeFeatures.IsRetweetFeature
import com.twitter.product_mixer.component_library.feature_hydrator.query.social_graph.SGSFollowedUsersFeature
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BulkCandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.util.OffloadFuturePools
import com.twitter.stitch.Stitch
object IsExtendedReplyFeatureHydrator
extends BulkCandidateFeatureHydrator[PipelineQuery, TweetCandidate] {
override val identifier: FeatureHydratorIdentifier = FeatureHydratorIdentifier("IsExtendedReply")
override def features: Set[Feature[_, _]] = Set(IsExtendedReplyFeature)
private val TrueFeatureMap = FeatureMapBuilder().add(IsExtendedReplyFeature, true).build()
private val FalseFeatureMap = FeatureMapBuilder().add(IsExtendedReplyFeature, false).build()
override def apply(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Stitch[Seq[FeatureMap]] = OffloadFuturePools.offload {
val followedUsers =
query.features.map(_.get(SGSFollowedUsersFeature)).getOrElse(Seq.empty).toSet
candidates.map { candidate =>
val features = candidate.features
val isExtendedReply = features.getOrElse(InReplyToTweetIdFeature, None).nonEmpty &&
!features.getOrElse(IsRetweetFeature, false) &&
features.getOrElse(InReplyToUserIdFeature, None).exists(!followedUsers.contains(_))
if (isExtendedReply) TrueFeatureMap else FalseFeatureMap
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/ListIdsQueryFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.QueryFeatureHydrator
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.socialgraph.{thriftscala => sg}
import com.twitter.stitch.Stitch
import com.twitter.stitch.socialgraph.SocialGraph
import javax.inject.Inject
import javax.inject.Singleton
case object ListIdsFeature extends FeatureWithDefaultOnFailure[PipelineQuery, Seq[Long]] {
override val defaultValue: Seq[Long] = Seq.empty
}
@Singleton
class ListIdsQueryFeatureHydrator @Inject() (socialGraph: SocialGraph)
extends QueryFeatureHydrator[PipelineQuery] {
override val identifier: FeatureHydratorIdentifier = FeatureHydratorIdentifier("ListIds")
override val features: Set[Feature[_, _]] = Set(ListIdsFeature)
private val MaxListsToFetch = 20
override def hydrate(query: PipelineQuery): Stitch[FeatureMap] = {
val userId = query.getRequiredUserId
val ownedSubscribedRequest = sg.IdsRequest(
relationships = Seq(
sg.SrcRelationship(userId, sg.RelationshipType.ListIsSubscriber, hasRelationship = true),
sg.SrcRelationship(userId, sg.RelationshipType.ListOwning, hasRelationship = true)
),
pageRequest = Some(sg.PageRequest(selectAll = Some(false), count = Some(MaxListsToFetch))),
context = Some(
sg.LookupContext(
includeInactive = false,
performUnion = Some(true),
includeAll = Some(false)
)
)
)
socialGraph.ids(ownedSubscribedRequest).map { response =>
FeatureMapBuilder().add(ListIdsFeature, response.ids).build()
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/MetricCenterUserCountingFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.finagle.stats.StatsReceiver
import com.twitter.home_mixer.model.HomeFeatures.AuthorIdFeature
import com.twitter.home_mixer.param.HomeMixerInjectionNames.MetricCenterUserCountingFeatureRepository
import com.twitter.home_mixer.util.ObservedKeyValueResultHandler
import com.twitter.onboarding.relevance.features.{thriftjava => rf}
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BulkCandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.util.OffloadFuturePools
import com.twitter.servo.keyvalue.KeyValueResult
import com.twitter.servo.repository.KeyValueRepository
import com.twitter.stitch.Stitch
import com.twitter.util.Future
import javax.inject.Inject
import javax.inject.Named
import javax.inject.Singleton
object MetricCenterUserCountingFeature
extends Feature[TweetCandidate, Option[rf.MCUserCountingFeatures]]
@Singleton
class MetricCenterUserCountingFeatureHydrator @Inject() (
@Named(MetricCenterUserCountingFeatureRepository) client: KeyValueRepository[Seq[
Long
], Long, rf.MCUserCountingFeatures],
override val statsReceiver: StatsReceiver)
extends BulkCandidateFeatureHydrator[PipelineQuery, TweetCandidate]
with ObservedKeyValueResultHandler {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("MetricCenterUserCounting")
override val features: Set[Feature[_, _]] = Set(MetricCenterUserCountingFeature)
override val statScope: String = identifier.toString
override def apply(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Stitch[Seq[FeatureMap]] = OffloadFuturePools.offloadFuture {
val possiblyAuthorIds = extractKeys(candidates)
val userIds = possiblyAuthorIds.flatten
val response: Future[KeyValueResult[Long, rf.MCUserCountingFeatures]] =
if (userIds.isEmpty) Future.value(KeyValueResult.empty) else client(userIds)
response.map { result =>
possiblyAuthorIds.map { possiblyAuthorId =>
val value = observedGet(key = possiblyAuthorId, keyValueResult = result)
FeatureMapBuilder().add(MetricCenterUserCountingFeature, value).build()
}
}
}
private def extractKeys(
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Seq[Option[Long]] = {
candidates.map { candidate =>
candidate.features
.getTry(AuthorIdFeature)
.toOption
.flatten
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/RealGraphQueryFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.home_mixer.param.HomeMixerInjectionNames.RealGraphFeatureRepository
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.QueryFeatureHydrator
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.servo.repository.Repository
import com.twitter.timelines.real_graph.{thriftscala => rg}
import com.twitter.stitch.Stitch
import com.twitter.timelines.model.UserId
import com.twitter.timelines.real_graph.v1.thriftscala.RealGraphEdgeFeatures
import com.twitter.user_session_store.{thriftscala => uss}
import javax.inject.Inject
import javax.inject.Named
import javax.inject.Singleton
object RealGraphFeatures extends Feature[PipelineQuery, Option[Map[UserId, RealGraphEdgeFeatures]]]
@Singleton
class RealGraphQueryFeatureHydrator @Inject() (
@Named(RealGraphFeatureRepository) repository: Repository[Long, Option[uss.UserSession]])
extends QueryFeatureHydrator[PipelineQuery] {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("RealGraphFeatures")
override val features: Set[Feature[_, _]] = Set(RealGraphFeatures)
override def hydrate(query: PipelineQuery): Stitch[FeatureMap] = {
Stitch.callFuture {
repository(query.getRequiredUserId).map { userSession =>
val realGraphFeaturesMap = userSession.flatMap { userSession =>
userSession.realGraphFeatures.collect {
case rg.RealGraphFeatures.V1(realGraphFeatures) =>
val edgeFeatures = realGraphFeatures.edgeFeatures ++ realGraphFeatures.oonEdgeFeatures
edgeFeatures.map { edge => edge.destId -> edge }.toMap
}
}
FeatureMapBuilder().add(RealGraphFeatures, realGraphFeaturesMap).build()
}
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/RealGraphViewerAuthorFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.home_mixer.model.HomeFeatures.AuthorIdFeature
import com.twitter.home_mixer.model.HomeFeatures.InReplyToUserIdFeature
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.RealGraphViewerAuthorFeatureHydrator.getCombinedRealGraphFeatures
import com.twitter.home_mixer.util.MissingKeyException
import com.twitter.ml.api.DataRecord
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.CandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.util.OffloadFuturePools
import com.twitter.stitch.Stitch
import com.twitter.timelines.prediction.adapters.real_graph.RealGraphEdgeFeaturesCombineAdapter
import com.twitter.timelines.prediction.adapters.real_graph.RealGraphFeaturesAdapter
import com.twitter.timelines.real_graph.v1.{thriftscala => v1}
import com.twitter.timelines.real_graph.{thriftscala => rg}
import com.twitter.util.Throw
import javax.inject.Inject
import javax.inject.Singleton
import scala.collection.JavaConverters._
object RealGraphViewerAuthorDataRecordFeature
extends DataRecordInAFeature[TweetCandidate]
with FeatureWithDefaultOnFailure[TweetCandidate, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
object RealGraphViewerAuthorsDataRecordFeature
extends DataRecordInAFeature[TweetCandidate]
with FeatureWithDefaultOnFailure[TweetCandidate, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
@Singleton
class RealGraphViewerAuthorFeatureHydrator @Inject() ()
extends CandidateFeatureHydrator[PipelineQuery, TweetCandidate] {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("RealGraphViewerAuthor")
override val features: Set[Feature[_, _]] =
Set(RealGraphViewerAuthorDataRecordFeature, RealGraphViewerAuthorsDataRecordFeature)
private val realGraphEdgeFeaturesAdapter = new RealGraphFeaturesAdapter
private val realGraphEdgeFeaturesCombineAdapter =
new RealGraphEdgeFeaturesCombineAdapter(prefix = "authors.realgraph")
private val MissingKeyFeatureMap = FeatureMapBuilder()
.add(RealGraphViewerAuthorDataRecordFeature, Throw(MissingKeyException))
.add(RealGraphViewerAuthorsDataRecordFeature, Throw(MissingKeyException))
.build()
override def apply(
query: PipelineQuery,
candidate: TweetCandidate,
existingFeatures: FeatureMap
): Stitch[FeatureMap] = OffloadFuturePools.offload {
val viewerId = query.getRequiredUserId
val realGraphFeatures = query.features
.flatMap(_.getOrElse(RealGraphFeatures, None))
.getOrElse(Map.empty[Long, v1.RealGraphEdgeFeatures])
existingFeatures.getOrElse(AuthorIdFeature, None) match {
case Some(authorId) =>
val realGraphAuthorFeatures =
getRealGraphViewerAuthorFeatures(viewerId, authorId, realGraphFeatures)
val realGraphAuthorDataRecord = realGraphEdgeFeaturesAdapter
.adaptToDataRecords(realGraphAuthorFeatures).asScala.headOption.getOrElse(new DataRecord)
val combinedRealGraphFeaturesDataRecord = for {
inReplyToAuthorId <- existingFeatures.getOrElse(InReplyToUserIdFeature, None)
} yield {
val combinedRealGraphFeatures =
getCombinedRealGraphFeatures(Seq(authorId, inReplyToAuthorId), realGraphFeatures)
realGraphEdgeFeaturesCombineAdapter
.adaptToDataRecords(Some(combinedRealGraphFeatures)).asScala.headOption
.getOrElse(new DataRecord)
}
FeatureMapBuilder()
.add(RealGraphViewerAuthorDataRecordFeature, realGraphAuthorDataRecord)
.add(
RealGraphViewerAuthorsDataRecordFeature,
combinedRealGraphFeaturesDataRecord.getOrElse(new DataRecord))
.build()
case _ => MissingKeyFeatureMap
}
}
private def getRealGraphViewerAuthorFeatures(
viewerId: Long,
authorId: Long,
realGraphEdgeFeaturesMap: Map[Long, v1.RealGraphEdgeFeatures]
): rg.UserRealGraphFeatures = {
realGraphEdgeFeaturesMap.get(authorId) match {
case Some(realGraphEdgeFeatures) =>
rg.UserRealGraphFeatures(
srcId = viewerId,
features = rg.RealGraphFeatures.V1(
v1.RealGraphFeatures(edgeFeatures = Seq(realGraphEdgeFeatures))))
case _ =>
rg.UserRealGraphFeatures(
srcId = viewerId,
features = rg.RealGraphFeatures.V1(v1.RealGraphFeatures(edgeFeatures = Seq.empty)))
}
}
}
object RealGraphViewerAuthorFeatureHydrator {
def getCombinedRealGraphFeatures(
userIds: Seq[Long],
realGraphEdgeFeaturesMap: Map[Long, v1.RealGraphEdgeFeatures]
): rg.RealGraphFeatures = {
val edgeFeatures = userIds.flatMap(realGraphEdgeFeaturesMap.get)
rg.RealGraphFeatures.V1(v1.RealGraphFeatures(edgeFeatures = edgeFeatures))
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/RealGraphViewerRelatedUsersFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.home_mixer.model.HomeFeatures.AuthorIdFeature
import com.twitter.home_mixer.model.HomeFeatures.DirectedAtUserIdFeature
import com.twitter.home_mixer.model.HomeFeatures.MentionUserIdFeature
import com.twitter.home_mixer.model.HomeFeatures.SourceUserIdFeature
import com.twitter.home_mixer.util.CandidatesUtil
import com.twitter.ml.api.DataRecord
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.CandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.util.OffloadFuturePools
import com.twitter.stitch.Stitch
import com.twitter.timelines.prediction.adapters.real_graph.RealGraphEdgeFeaturesCombineAdapter
import com.twitter.timelines.real_graph.v1.{thriftscala => v1}
import javax.inject.Inject
import javax.inject.Singleton
import scala.collection.JavaConverters._
object RealGraphViewerRelatedUsersDataRecordFeature
extends DataRecordInAFeature[TweetCandidate]
with FeatureWithDefaultOnFailure[TweetCandidate, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
@Singleton
class RealGraphViewerRelatedUsersFeatureHydrator @Inject() ()
extends CandidateFeatureHydrator[PipelineQuery, TweetCandidate] {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("RealGraphViewerRelatedUsers")
override val features: Set[Feature[_, _]] = Set(RealGraphViewerRelatedUsersDataRecordFeature)
private val RealGraphEdgeFeaturesCombineAdapter = new RealGraphEdgeFeaturesCombineAdapter
override def apply(
query: PipelineQuery,
candidate: TweetCandidate,
existingFeatures: FeatureMap
): Stitch[FeatureMap] = OffloadFuturePools.offload {
val realGraphQueryFeatures = query.features
.flatMap(_.getOrElse(RealGraphFeatures, None))
.getOrElse(Map.empty[Long, v1.RealGraphEdgeFeatures])
val allRelatedUserIds = getRelatedUserIds(existingFeatures)
val realGraphFeatures = RealGraphViewerAuthorFeatureHydrator.getCombinedRealGraphFeatures(
allRelatedUserIds,
realGraphQueryFeatures
)
val realGraphFeaturesDataRecord = RealGraphEdgeFeaturesCombineAdapter
.adaptToDataRecords(Some(realGraphFeatures)).asScala.headOption
.getOrElse(new DataRecord)
FeatureMapBuilder()
.add(RealGraphViewerRelatedUsersDataRecordFeature, realGraphFeaturesDataRecord)
.build()
}
private def getRelatedUserIds(features: FeatureMap): Seq[Long] = {
(CandidatesUtil.getEngagerUserIds(features) ++
features.getOrElse(AuthorIdFeature, None) ++
features.getOrElse(MentionUserIdFeature, Seq.empty) ++
features.getOrElse(SourceUserIdFeature, None) ++
features.getOrElse(DirectedAtUserIdFeature, None)).distinct
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/RealTimeInteractionGraphEdgeFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.home_mixer.model.HomeFeatures.AuthorIdFeature
import com.twitter.ml.api.DataRecord
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BulkCandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.util.OffloadFuturePools
import com.twitter.stitch.Stitch
import com.twitter.timelines.prediction.adapters.realtime_interaction_graph.RealTimeInteractionGraphFeaturesAdapter
import com.twitter.timelines.prediction.features.realtime_interaction_graph.RealTimeInteractionGraphEdgeFeatures
import com.twitter.util.Time
import javax.inject.Inject
import javax.inject.Singleton
import scala.collection.JavaConverters._
object RealTimeInteractionGraphEdgeFeature
extends DataRecordInAFeature[TweetCandidate]
with FeatureWithDefaultOnFailure[TweetCandidate, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
@Singleton
class RealTimeInteractionGraphEdgeFeatureHydrator @Inject() ()
extends BulkCandidateFeatureHydrator[PipelineQuery, TweetCandidate] {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("RealTimeInteractionGraphEdge")
override val features: Set[Feature[_, _]] = Set(RealTimeInteractionGraphEdgeFeature)
private val realTimeInteractionGraphFeaturesAdapter = new RealTimeInteractionGraphFeaturesAdapter
override def apply(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Stitch[Seq[FeatureMap]] = OffloadFuturePools.offload {
val userVertex =
query.features.flatMap(_.getOrElse(RealTimeInteractionGraphUserVertexQueryFeature, None))
val realTimeInteractionGraphFeaturesMap =
userVertex.map(RealTimeInteractionGraphEdgeFeatures(_, Time.now))
candidates.map { candidate =>
val feature = candidate.features.getOrElse(AuthorIdFeature, None).flatMap { authorId =>
realTimeInteractionGraphFeaturesMap.flatMap(_.get(authorId))
}
val dataRecordFeature =
realTimeInteractionGraphFeaturesAdapter.adaptToDataRecords(feature).asScala.head
FeatureMapBuilder().add(RealTimeInteractionGraphEdgeFeature, dataRecordFeature).build()
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/RealTimeInteractionGraphUserVertexQueryFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.google.inject.name.Named
import com.twitter.finagle.stats.StatsReceiver
import com.twitter.home_mixer.param.HomeMixerInjectionNames.RealTimeInteractionGraphUserVertexCache
import com.twitter.home_mixer.util.ObservedKeyValueResultHandler
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.QueryFeatureHydrator
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.servo.cache.ReadCache
import com.twitter.stitch.Stitch
import com.twitter.wtf.real_time_interaction_graph.{thriftscala => ig}
import javax.inject.Inject
import javax.inject.Singleton
object RealTimeInteractionGraphUserVertexQueryFeature
extends Feature[PipelineQuery, Option[ig.UserVertex]]
@Singleton
class RealTimeInteractionGraphUserVertexQueryFeatureHydrator @Inject() (
@Named(RealTimeInteractionGraphUserVertexCache) client: ReadCache[Long, ig.UserVertex],
override val statsReceiver: StatsReceiver)
extends QueryFeatureHydrator[PipelineQuery]
with ObservedKeyValueResultHandler {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("RealTimeInteractionGraphUserVertex")
override val features: Set[Feature[_, _]] = Set(RealTimeInteractionGraphUserVertexQueryFeature)
override val statScope: String = identifier.toString
override def hydrate(query: PipelineQuery): Stitch[FeatureMap] = {
val userId = query.getRequiredUserId
Stitch.callFuture(
client.get(Seq(userId)).map { results =>
val feature = observedGet(key = Some(userId), keyValueResult = results)
FeatureMapBuilder()
.add(RealTimeInteractionGraphUserVertexQueryFeature, feature)
.build()
}
)
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/ReplyFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.finagle.stats.StatsReceiver
import com.twitter.home_mixer.model.ContentFeatures
import com.twitter.home_mixer.model.HomeFeatures._
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.adapters.content.InReplyToContentFeatureAdapter
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.adapters.earlybird.InReplyToEarlybirdAdapter
import com.twitter.home_mixer.util.ReplyRetweetUtil
import com.twitter.ml.api.DataRecord
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BulkCandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.util.OffloadFuturePools
import com.twitter.search.common.features.thriftscala.ThriftTweetFeatures
import com.twitter.snowflake.id.SnowflakeId
import com.twitter.stitch.Stitch
import com.twitter.timelines.conversation_features.v1.thriftscala.ConversationFeatures
import com.twitter.timelines.conversation_features.{thriftscala => cf}
import com.twitter.timelines.prediction.adapters.conversation_features.ConversationFeaturesAdapter
import com.twitter.util.Duration
import com.twitter.util.Time
import javax.inject.Inject
import javax.inject.Singleton
import scala.collection.JavaConverters._
object InReplyToTweetHydratedEarlybirdFeature
extends Feature[TweetCandidate, Option[ThriftTweetFeatures]]
object ConversationDataRecordFeature
extends DataRecordInAFeature[TweetCandidate]
with FeatureWithDefaultOnFailure[TweetCandidate, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
object InReplyToEarlybirdDataRecordFeature
extends DataRecordInAFeature[TweetCandidate]
with FeatureWithDefaultOnFailure[TweetCandidate, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
object InReplyToTweetypieContentDataRecordFeature
extends DataRecordInAFeature[TweetCandidate]
with FeatureWithDefaultOnFailure[TweetCandidate, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
/**
* The purpose of this hydrator is to
* 1) hydrate simple features into replies and their ancestor tweets
* 2) keep both the normal replies and ancestor source candidates, but hydrate into the candidates
* features useful for predicting the quality of the replies and source ancestor tweets.
*/
@Singleton
class ReplyFeatureHydrator @Inject() (statsReceiver: StatsReceiver)
extends BulkCandidateFeatureHydrator[PipelineQuery, TweetCandidate] {
override val identifier: FeatureHydratorIdentifier = FeatureHydratorIdentifier("ReplyTweet")
override val features: Set[Feature[_, _]] = Set(
ConversationDataRecordFeature,
InReplyToTweetHydratedEarlybirdFeature,
InReplyToEarlybirdDataRecordFeature,
InReplyToTweetypieContentDataRecordFeature
)
private val defaulDataRecord: DataRecord = new DataRecord()
private val DefaultFeatureMap = FeatureMapBuilder()
.add(ConversationDataRecordFeature, defaulDataRecord)
.add(InReplyToTweetHydratedEarlybirdFeature, None)
.add(InReplyToEarlybirdDataRecordFeature, defaulDataRecord)
.add(InReplyToTweetypieContentDataRecordFeature, defaulDataRecord)
.build()
private val scopedStatsReceiver = statsReceiver.scope(getClass.getSimpleName)
private val hydratedReplyCounter = scopedStatsReceiver.counter("hydratedReply")
private val hydratedAncestorCounter = scopedStatsReceiver.counter("hydratedAncestor")
override def apply(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Stitch[Seq[FeatureMap]] = OffloadFuturePools.offload {
val replyToInReplyToTweetMap =
ReplyRetweetUtil.replyTweetIdToInReplyToTweetMap(candidates)
val candidatesWithRepliesHydrated = candidates.map { candidate =>
replyToInReplyToTweetMap
.get(candidate.candidate.id).map { inReplyToTweet =>
hydratedReplyCounter.incr()
hydratedReplyCandidate(candidate, inReplyToTweet)
}.getOrElse((candidate, None, None))
}
/**
* Update ancestor tweets with descendant replies and hydrate simple features from one of
* the descendants.
*/
val ancestorTweetToDescendantRepliesMap =
ReplyRetweetUtil.ancestorTweetIdToDescendantRepliesMap(candidates)
val candidatesWithRepliesAndAncestorTweetsHydrated = candidatesWithRepliesHydrated.map {
case (
maybeAncestorTweetCandidate,
updatedReplyConversationFeatures,
inReplyToTweetEarlyBirdFeature) =>
ancestorTweetToDescendantRepliesMap
.get(maybeAncestorTweetCandidate.candidate.id)
.map { descendantReplies =>
hydratedAncestorCounter.incr()
val (ancestorTweetCandidate, updatedConversationFeatures): (
CandidateWithFeatures[TweetCandidate],
Option[ConversationFeatures]
) =
hydrateAncestorTweetCandidate(
maybeAncestorTweetCandidate,
descendantReplies,
updatedReplyConversationFeatures)
(ancestorTweetCandidate, inReplyToTweetEarlyBirdFeature, updatedConversationFeatures)
}
.getOrElse(
(
maybeAncestorTweetCandidate,
inReplyToTweetEarlyBirdFeature,
updatedReplyConversationFeatures))
}
candidatesWithRepliesAndAncestorTweetsHydrated.map {
case (candidate, inReplyToTweetEarlyBirdFeature, updatedConversationFeatures) =>
val conversationDataRecordFeature = updatedConversationFeatures
.map(f => ConversationFeaturesAdapter.adaptToDataRecord(cf.ConversationFeatures.V1(f)))
.getOrElse(defaulDataRecord)
val inReplyToEarlybirdDataRecord =
InReplyToEarlybirdAdapter
.adaptToDataRecords(inReplyToTweetEarlyBirdFeature).asScala.head
val inReplyToContentDataRecord = InReplyToContentFeatureAdapter
.adaptToDataRecords(
inReplyToTweetEarlyBirdFeature.map(ContentFeatures.fromThrift)).asScala.head
FeatureMapBuilder()
.add(ConversationDataRecordFeature, conversationDataRecordFeature)
.add(InReplyToTweetHydratedEarlybirdFeature, inReplyToTweetEarlyBirdFeature)
.add(InReplyToEarlybirdDataRecordFeature, inReplyToEarlybirdDataRecord)
.add(InReplyToTweetypieContentDataRecordFeature, inReplyToContentDataRecord)
.build()
case _ => DefaultFeatureMap
}
}
private def hydratedReplyCandidate(
replyCandidate: CandidateWithFeatures[TweetCandidate],
inReplyToTweetCandidate: CandidateWithFeatures[TweetCandidate]
): (
CandidateWithFeatures[TweetCandidate],
Option[ConversationFeatures],
Option[ThriftTweetFeatures]
) = {
val tweetedAfterInReplyToTweetInSecs =
(
originalTweetAgeFromSnowflake(inReplyToTweetCandidate),
originalTweetAgeFromSnowflake(replyCandidate)) match {
case (Some(inReplyToTweetAge), Some(replyTweetAge)) =>
Some((inReplyToTweetAge - replyTweetAge).inSeconds.toLong)
case _ => None
}
val existingConversationFeatures = Some(
replyCandidate.features
.getOrElse(ConversationFeature, None).getOrElse(ConversationFeatures()))
val updatedConversationFeatures = existingConversationFeatures match {
case Some(v1) =>
Some(
v1.copy(
tweetedAfterInReplyToTweetInSecs = tweetedAfterInReplyToTweetInSecs,
isSelfReply = Some(
replyCandidate.features.getOrElse(
AuthorIdFeature,
None) == inReplyToTweetCandidate.features.getOrElse(AuthorIdFeature, None))
)
)
case _ => None
}
// Note: if inReplyToTweet is a retweet, we need to read early bird feature from the merged
// early bird feature field from RetweetSourceTweetFeatureHydrator class.
// But if inReplyToTweet is a reply, we return its early bird feature directly
val inReplyToTweetThriftTweetFeaturesOpt = {
if (inReplyToTweetCandidate.features.getOrElse(IsRetweetFeature, false)) {
inReplyToTweetCandidate.features.getOrElse(SourceTweetEarlybirdFeature, None)
} else {
inReplyToTweetCandidate.features.getOrElse(EarlybirdFeature, None)
}
}
(replyCandidate, updatedConversationFeatures, inReplyToTweetThriftTweetFeaturesOpt)
}
private def hydrateAncestorTweetCandidate(
ancestorTweetCandidate: CandidateWithFeatures[TweetCandidate],
descendantReplies: Seq[CandidateWithFeatures[TweetCandidate]],
updatedReplyConversationFeatures: Option[ConversationFeatures]
): (CandidateWithFeatures[TweetCandidate], Option[ConversationFeatures]) = {
// Ancestor could be a reply. For example, in thread: tweetA -> tweetB -> tweetC,
// tweetB is a reply and ancestor at the same time. Hence, tweetB's conversation feature
// will be updated by hydratedReplyCandidate and hydrateAncestorTweetCandidate functions.
val existingConversationFeatures =
if (updatedReplyConversationFeatures.nonEmpty)
updatedReplyConversationFeatures
else
Some(
ancestorTweetCandidate.features
.getOrElse(ConversationFeature, None).getOrElse(ConversationFeatures()))
val updatedConversationFeatures = existingConversationFeatures match {
case Some(v1) =>
Some(
v1.copy(
hasDescendantReplyCandidate = Some(true),
hasInNetworkDescendantReply =
Some(descendantReplies.exists(_.features.getOrElse(InNetworkFeature, false)))
))
case _ => None
}
(ancestorTweetCandidate, updatedConversationFeatures)
}
private def originalTweetAgeFromSnowflake(
candidate: CandidateWithFeatures[TweetCandidate]
): Option[Duration] = {
SnowflakeId
.timeFromIdOpt(
candidate.features
.getOrElse(SourceTweetIdFeature, None).getOrElse(candidate.candidate.id))
.map(Time.now - _)
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/RequestTimeQueryFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.conversions.DurationOps._
import com.twitter.home_mixer.model.HomeFeatures.FollowingLastNonPollingTimeFeature
import com.twitter.home_mixer.model.HomeFeatures.LastNonPollingTimeFeature
import com.twitter.home_mixer.model.HomeFeatures.NonPollingTimesFeature
import com.twitter.ml.api.DataRecord
import com.twitter.ml.api.util.FDsl._
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.QueryFeatureHydrator
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.snowflake.id.SnowflakeId
import com.twitter.stitch.Stitch
import com.twitter.timelines.prediction.features.time_features.AccountAgeInterval
import com.twitter.timelines.prediction.features.time_features.TimeDataRecordFeatures.ACCOUNT_AGE_INTERVAL
import com.twitter.timelines.prediction.features.time_features.TimeDataRecordFeatures.IS_12_MONTH_NEW_USER
import com.twitter.timelines.prediction.features.time_features.TimeDataRecordFeatures.IS_30_DAY_NEW_USER
import com.twitter.timelines.prediction.features.time_features.TimeDataRecordFeatures.TIME_BETWEEN_NON_POLLING_REQUESTS_AVG
import com.twitter.timelines.prediction.features.time_features.TimeDataRecordFeatures.TIME_SINCE_LAST_NON_POLLING_REQUEST
import com.twitter.timelines.prediction.features.time_features.TimeDataRecordFeatures.TIME_SINCE_VIEWER_ACCOUNT_CREATION_SECS
import com.twitter.timelines.prediction.features.time_features.TimeDataRecordFeatures.USER_ID_IS_SNOWFLAKE_ID
import com.twitter.user_session_store.ReadRequest
import com.twitter.user_session_store.ReadWriteUserSessionStore
import com.twitter.user_session_store.UserSessionDataset
import com.twitter.user_session_store.UserSessionDataset.UserSessionDataset
import com.twitter.util.Time
import javax.inject.Inject
import javax.inject.Singleton
object RequestTimeDataRecordFeature
extends DataRecordInAFeature[PipelineQuery]
with FeatureWithDefaultOnFailure[PipelineQuery, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
@Singleton
case class RequestTimeQueryFeatureHydrator @Inject() (
userSessionStore: ReadWriteUserSessionStore)
extends QueryFeatureHydrator[PipelineQuery] {
override val identifier: FeatureHydratorIdentifier = FeatureHydratorIdentifier("RequestTime")
override val features: Set[Feature[_, _]] = Set(
FollowingLastNonPollingTimeFeature,
LastNonPollingTimeFeature,
NonPollingTimesFeature,
RequestTimeDataRecordFeature
)
private val datasets: Set[UserSessionDataset] = Set(UserSessionDataset.NonPollingTimes)
override def hydrate(query: PipelineQuery): Stitch[FeatureMap] = {
userSessionStore
.read(ReadRequest(query.getRequiredUserId, datasets))
.map { userSession =>
val nonPollingTimestamps = userSession.flatMap(_.nonPollingTimestamps)
val lastNonPollingTime = nonPollingTimestamps
.flatMap(_.nonPollingTimestampsMs.headOption)
.map(Time.fromMilliseconds)
val followingLastNonPollingTime = nonPollingTimestamps
.flatMap(_.mostRecentHomeLatestNonPollingTimestampMs)
.map(Time.fromMilliseconds)
val nonPollingTimes = nonPollingTimestamps
.map(_.nonPollingTimestampsMs)
.getOrElse(Seq.empty)
val requestTimeDataRecord = getRequestTimeDataRecord(query, nonPollingTimes)
FeatureMapBuilder()
.add(FollowingLastNonPollingTimeFeature, followingLastNonPollingTime)
.add(LastNonPollingTimeFeature, lastNonPollingTime)
.add(NonPollingTimesFeature, nonPollingTimes)
.add(RequestTimeDataRecordFeature, requestTimeDataRecord)
.build()
}
}
def getRequestTimeDataRecord(query: PipelineQuery, nonPollingTimes: Seq[Long]): DataRecord = {
val requestTimeMs = query.queryTime.inMillis
val accountAge = SnowflakeId.timeFromIdOpt(query.getRequiredUserId)
val timeSinceAccountCreation = accountAge.map(query.queryTime.since)
val timeSinceEarliestNonPollingRequest =
nonPollingTimes.lastOption.map(requestTimeMs - _)
val timeSinceLastNonPollingRequest =
nonPollingTimes.headOption.map(requestTimeMs - _)
new DataRecord()
.setFeatureValue(USER_ID_IS_SNOWFLAKE_ID, accountAge.isDefined)
.setFeatureValue(
IS_30_DAY_NEW_USER,
timeSinceAccountCreation.map(_ < 30.days).getOrElse(false)
)
.setFeatureValue(
IS_12_MONTH_NEW_USER,
timeSinceAccountCreation.map(_ < 365.days).getOrElse(false)
)
.setFeatureValueFromOption(
ACCOUNT_AGE_INTERVAL,
timeSinceAccountCreation.flatMap(AccountAgeInterval.fromDuration).map(_.id.toLong)
)
.setFeatureValueFromOption(
TIME_SINCE_VIEWER_ACCOUNT_CREATION_SECS,
timeSinceAccountCreation.map(_.inSeconds.toDouble)
)
.setFeatureValueFromOption(
TIME_BETWEEN_NON_POLLING_REQUESTS_AVG,
timeSinceEarliestNonPollingRequest.map(_.toDouble / math.max(1.0, nonPollingTimes.size))
)
.setFeatureValueFromOption(
TIME_SINCE_LAST_NON_POLLING_REQUEST,
timeSinceLastNonPollingRequest.map(_.toDouble)
)
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/RetweetSourceTweetFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.home_mixer.model.HomeFeatures._
import com.twitter.product_mixer.component_library.candidate_source.timeline_ranker.TimelineRankerInNetworkSourceTweetsByTweetIdMapFeature
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BulkCandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.search.common.features.thriftscala.ThriftTweetFeatures
import com.twitter.stitch.Stitch
import com.twitter.timelineranker.thriftscala.CandidateTweet
object SourceTweetEarlybirdFeature extends Feature[TweetCandidate, Option[ThriftTweetFeatures]]
/**
* Feature Hydrator that bulk hydrates source tweets' features to retweet candidates
*/
object RetweetSourceTweetFeatureHydrator
extends BulkCandidateFeatureHydrator[PipelineQuery, TweetCandidate] {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("RetweetSourceTweet")
override val features: Set[Feature[_, _]] = Set(
SourceTweetEarlybirdFeature,
)
private val DefaultFeatureMap = FeatureMapBuilder()
.add(SourceTweetEarlybirdFeature, None)
.build()
override def apply(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Stitch[Seq[FeatureMap]] = {
val sourceTweetsByTweetId: Option[Map[Long, CandidateTweet]] = {
query.features.map(
_.getOrElse(
TimelineRankerInNetworkSourceTweetsByTweetIdMapFeature,
Map.empty[Long, CandidateTweet]))
}
/**
* Return DefaultFeatureMap (no-op to candidate) when it is unfeasible to hydrate the
* source tweet's feature to the current candidate: early bird does not return source
* tweets info / candidate is not a retweet / sourceTweetId is not found
*/
Stitch.value {
if (sourceTweetsByTweetId.exists(_.nonEmpty)) {
candidates.map { candidate =>
val candidateIsRetweet = candidate.features.getOrElse(IsRetweetFeature, false)
val sourceTweetId = candidate.features.getOrElse(SourceTweetIdFeature, None)
if (!candidateIsRetweet || sourceTweetId.isEmpty) {
DefaultFeatureMap
} else {
val sourceTweet = sourceTweetsByTweetId.flatMap(_.get(sourceTweetId.get))
if (sourceTweet.nonEmpty) {
val source = sourceTweet.get
FeatureMapBuilder()
.add(SourceTweetEarlybirdFeature, source.features)
.build()
} else {
DefaultFeatureMap
}
}
}
} else {
candidates.map(_ => DefaultFeatureMap)
}
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/SimClustersEngagementSimilarityFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.home_mixer.product.scored_tweets.param.ScoredTweetsParam
import com.twitter.ml.api.DataRecord
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BulkCandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.Conditionally
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.util.OffloadFuturePools
import com.twitter.stitch.Stitch
import com.twitter.timelines.clients.strato.twistly.SimClustersRecentEngagementSimilarityClient
import com.twitter.timelines.configapi.decider.BooleanDeciderParam
import com.twitter.timelines.prediction.adapters.twistly.SimClustersRecentEngagementSimilarityFeaturesAdapter
import javax.inject.Inject
import javax.inject.Singleton
object SimClustersEngagementSimilarityFeature
extends DataRecordInAFeature[PipelineQuery]
with FeatureWithDefaultOnFailure[PipelineQuery, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
@Singleton
class SimClustersEngagementSimilarityFeatureHydrator @Inject() (
simClustersEngagementSimilarityClient: SimClustersRecentEngagementSimilarityClient)
extends BulkCandidateFeatureHydrator[PipelineQuery, TweetCandidate]
with Conditionally[PipelineQuery] {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("SimClustersEngagementSimilarity")
override val features: Set[Feature[_, _]] = Set(SimClustersEngagementSimilarityFeature)
private val simClustersRecentEngagementSimilarityFeaturesAdapter =
new SimClustersRecentEngagementSimilarityFeaturesAdapter
override def onlyIf(query: PipelineQuery): Boolean = {
val param: BooleanDeciderParam =
ScoredTweetsParam.EnableSimClustersSimilarityFeatureHydrationDeciderParam
query.params.apply(param)
}
override def apply(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Stitch[Seq[FeatureMap]] = OffloadFuturePools.offloadFuture {
val tweetToCandidates = candidates.map(candidate => candidate.candidate.id -> candidate).toMap
val tweetIds = tweetToCandidates.keySet.toSeq
val userId = query.getRequiredUserId
val userTweetEdges = tweetIds.map(tweetId => (userId, tweetId))
simClustersEngagementSimilarityClient
.getSimClustersRecentEngagementSimilarityScores(userTweetEdges).map {
simClustersRecentEngagementSimilarityScoresMap =>
candidates.map { candidate =>
val similarityFeatureOpt = simClustersRecentEngagementSimilarityScoresMap
.get(userId -> candidate.candidate.id).flatten
val dataRecordOpt = similarityFeatureOpt.map { similarityFeature =>
simClustersRecentEngagementSimilarityFeaturesAdapter
.adaptToDataRecords(similarityFeature)
.get(0)
}
FeatureMapBuilder()
.add(SimClustersEngagementSimilarityFeature, dataRecordOpt.getOrElse(new DataRecord))
.build()
}
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/SimClustersUserTweetScoresHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.dal.personal_data.{thriftjava => pd}
import com.twitter.finagle.stats.StatsReceiver
import com.twitter.home_mixer.model.HomeFeatures.EarlybirdFeature
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.datarecord.DataRecordOptionalFeature
import com.twitter.product_mixer.core.feature.datarecord.DoubleDataRecordCompatible
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BulkCandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.util.OffloadFuturePools
import com.twitter.stitch.Stitch
import com.twitter.strato.catalog.Fetch
import com.twitter.strato.generated.client.ml.featureStore.SimClustersUserInterestedInTweetEmbeddingDotProduct20M145K2020OnUserTweetEdgeClientColumn
import javax.inject.Inject
import javax.inject.Singleton
object SimClustersUserInterestedInTweetEmbeddingDataRecordFeature
extends DataRecordOptionalFeature[TweetCandidate, Double]
with DoubleDataRecordCompatible {
override val featureName: String =
"user-tweet.recommendations.sim_clusters_scores.user_interested_in_tweet_embedding_dot_product_20m_145k_2020"
override val personalDataTypes: Set[pd.PersonalDataType] =
Set(pd.PersonalDataType.InferredInterests)
}
@Singleton
class SimClustersUserTweetScoresHydrator @Inject() (
simClustersColumn: SimClustersUserInterestedInTweetEmbeddingDotProduct20M145K2020OnUserTweetEdgeClientColumn,
statsReceiver: StatsReceiver)
extends BulkCandidateFeatureHydrator[PipelineQuery, TweetCandidate] {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("SimClustersUserTweetScores")
override val features: Set[Feature[_, _]] = Set(
SimClustersUserInterestedInTweetEmbeddingDataRecordFeature)
private val scopedStatsReceiver = statsReceiver.scope(getClass.getSimpleName)
private val keyFoundCounter = scopedStatsReceiver.counter("key/found")
private val keyLossCounter = scopedStatsReceiver.counter("key/loss")
private val keyFailureCounter = scopedStatsReceiver.counter("key/failure")
private val keySkipCounter = scopedStatsReceiver.counter("key/skip")
private val DefaultFeatureMap = FeatureMapBuilder()
.add(SimClustersUserInterestedInTweetEmbeddingDataRecordFeature, None)
.build()
private val MinFavToHydrate = 9
override def apply(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Stitch[Seq[FeatureMap]] = OffloadFuturePools.offloadFuture {
Stitch.run {
Stitch.collect {
candidates.map { candidate =>
val ebFeatures = candidate.features.getOrElse(EarlybirdFeature, None)
val favCount = ebFeatures.flatMap(_.favCountV2).getOrElse(0)
if (ebFeatures.isEmpty || favCount >= MinFavToHydrate) {
simClustersColumn.fetcher
.fetch((query.getRequiredUserId, candidate.candidate.id), Unit)
.map {
case Fetch.Result(response, _) =>
if (response.nonEmpty) keyFoundCounter.incr() else keyLossCounter.incr()
FeatureMapBuilder()
.add(SimClustersUserInterestedInTweetEmbeddingDataRecordFeature, response)
.build()
case _ =>
keyFailureCounter.incr()
DefaultFeatureMap
}
} else {
keySkipCounter.incr()
Stitch.value(DefaultFeatureMap)
}
}
}
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/TSPInferredTopicFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.contentrecommender.{thriftscala => cr}
import com.twitter.home_mixer.model.HomeFeatures.CandidateSourceIdFeature
import com.twitter.home_mixer.model.HomeFeatures.TSPMetricTagFeature
import com.twitter.home_mixer.model.HomeFeatures.TopicContextFunctionalityTypeFeature
import com.twitter.home_mixer.model.HomeFeatures.TopicIdSocialContextFeature
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.adapters.inferred_topic.InferredTopicAdapter
import com.twitter.ml.api.DataRecord
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BulkCandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.model.marshalling.response.urt.metadata.BasicTopicContextFunctionalityType
import com.twitter.product_mixer.core.model.marshalling.response.urt.metadata.RecommendationTopicContextFunctionalityType
import com.twitter.product_mixer.core.model.marshalling.response.urt.metadata.TopicContextFunctionalityType
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.util.OffloadFuturePools
import com.twitter.stitch.Stitch
import com.twitter.timelines.clients.strato.topics.TopicSocialProofClient
import com.twitter.timelineservice.suggests.logging.candidate_tweet_source_id.{thriftscala => sid}
import com.twitter.topiclisting.TopicListingViewerContext
import com.twitter.tsp.{thriftscala => tsp}
import javax.inject.Inject
import javax.inject.Singleton
import scala.collection.JavaConverters._
object TSPInferredTopicFeature extends Feature[TweetCandidate, Map[Long, Double]]
object TSPInferredTopicDataRecordFeature
extends DataRecordInAFeature[TweetCandidate]
with FeatureWithDefaultOnFailure[TweetCandidate, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
@Singleton
class TSPInferredTopicFeatureHydrator @Inject() (
topicSocialProofClient: TopicSocialProofClient)
extends BulkCandidateFeatureHydrator[PipelineQuery, TweetCandidate] {
override val identifier: FeatureHydratorIdentifier = FeatureHydratorIdentifier("TSPInferredTopic")
override val features: Set[Feature[_, _]] = Set(
TSPInferredTopicFeature,
TSPInferredTopicDataRecordFeature,
TopicIdSocialContextFeature,
TopicContextFunctionalityTypeFeature
)
private val topK = 3
private val SourcesToSetSocialProof: Set[sid.CandidateTweetSourceId] =
Set(sid.CandidateTweetSourceId.Simcluster)
private val DefaultFeatureMap = FeatureMapBuilder()
.add(TSPInferredTopicFeature, Map.empty[Long, Double])
.add(TSPInferredTopicDataRecordFeature, new DataRecord())
.add(TopicIdSocialContextFeature, None)
.add(TopicContextFunctionalityTypeFeature, None)
.build()
override def apply(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Stitch[Seq[FeatureMap]] = OffloadFuturePools.offloadFuture {
val tags = candidates.collect {
case candidate if candidate.features.getTry(TSPMetricTagFeature).isReturn =>
candidate.candidate.id -> candidate.features
.getOrElse(TSPMetricTagFeature, Set.empty[tsp.MetricTag])
}.toMap
val topicSocialProofRequest = tsp.TopicSocialProofRequest(
userId = query.getRequiredUserId,
tweetIds = candidates.map(_.candidate.id).toSet,
displayLocation = cr.DisplayLocation.HomeTimeline,
topicListingSetting = tsp.TopicListingSetting.Followable,
context = TopicListingViewerContext.fromClientContext(query.clientContext).toThrift,
bypassModes = None,
// Only TweetMixer source has this data. Convert the TweetMixer metric tag to tsp metric tag.
tags = if (tags.isEmpty) None else Some(tags)
)
topicSocialProofClient
.getTopicTweetSocialProofResponse(topicSocialProofRequest)
.map {
case Some(response) =>
handleResponse(response, candidates)
case _ => candidates.map { _ => DefaultFeatureMap }
}
}
private def handleResponse(
response: tsp.TopicSocialProofResponse,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Seq[FeatureMap] = {
candidates.map { candidate =>
val topicWithScores = response.socialProofs.getOrElse(candidate.candidate.id, Seq.empty)
if (topicWithScores.nonEmpty) {
val (socialProofId, socialProofFunctionalityType) =
if (candidate.features
.getOrElse(CandidateSourceIdFeature, None)
.exists(SourcesToSetSocialProof.contains)) {
getSocialProof(topicWithScores)
} else (None, None)
val inferredTopicFeatures =
topicWithScores.sortBy(-_.score).take(topK).map(a => (a.topicId, a.score)).toMap
val inferredTopicDataRecord =
InferredTopicAdapter.adaptToDataRecords(inferredTopicFeatures).asScala.head
FeatureMapBuilder()
.add(TSPInferredTopicFeature, inferredTopicFeatures)
.add(TSPInferredTopicDataRecordFeature, inferredTopicDataRecord)
.add(TopicIdSocialContextFeature, socialProofId)
.add(TopicContextFunctionalityTypeFeature, socialProofFunctionalityType)
.build()
} else DefaultFeatureMap
}
}
private def getSocialProof(
topicWithScores: Seq[tsp.TopicWithScore]
): (Option[Long], Option[TopicContextFunctionalityType]) = {
val followingTopicId = topicWithScores.collectFirst {
case tsp.TopicWithScore(topicId, _, _, Some(tsp.TopicFollowType.Following)) => topicId
}
if (followingTopicId.nonEmpty) {
return (followingTopicId, Some(BasicTopicContextFunctionalityType))
}
val implicitFollowingId = topicWithScores.collectFirst {
case tsp.TopicWithScore(topicId, _, _, Some(tsp.TopicFollowType.ImplicitFollow)) =>
topicId
}
if (implicitFollowingId.nonEmpty) {
return (implicitFollowingId, Some(RecommendationTopicContextFunctionalityType))
}
(None, None)
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/TweetMetaDataFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.home_mixer.model.HomeFeatures.CandidateSourceIdFeature
import com.twitter.home_mixer.util.CandidatesUtil
import com.twitter.ml.api.DataRecord
import com.twitter.ml.api.RichDataRecord
import com.twitter.ml.api.constant.SharedFeatures
import com.twitter.ml.api.util.DataRecordConverters._
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.CandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.util.OffloadFuturePools
import com.twitter.stitch.Stitch
import com.twitter.timelines.prediction.features.common.TimelinesSharedFeatures
import java.lang.{Long => JLong}
object TweetMetaDataDataRecord
extends DataRecordInAFeature[TweetCandidate]
with FeatureWithDefaultOnFailure[TweetCandidate, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
object TweetMetaDataFeatureHydrator
extends CandidateFeatureHydrator[PipelineQuery, TweetCandidate] {
override val identifier: FeatureHydratorIdentifier = FeatureHydratorIdentifier("TweetMetaData")
override def features: Set[Feature[_, _]] = Set(TweetMetaDataDataRecord)
override def apply(
query: PipelineQuery,
candidate: TweetCandidate,
existingFeatures: FeatureMap
): Stitch[FeatureMap] = OffloadFuturePools.offload {
val richDataRecord = new RichDataRecord()
setFeatures(richDataRecord, candidate, existingFeatures)
FeatureMapBuilder().add(TweetMetaDataDataRecord, richDataRecord.getRecord).build()
}
private def setFeatures(
richDataRecord: RichDataRecord,
candidate: TweetCandidate,
existingFeatures: FeatureMap
): Unit = {
richDataRecord.setFeatureValue[JLong](SharedFeatures.TWEET_ID, candidate.id)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.ORIGINAL_AUTHOR_ID,
CandidatesUtil.getOriginalAuthorId(existingFeatures))
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.CANDIDATE_TWEET_SOURCE_ID,
existingFeatures.getOrElse(CandidateSourceIdFeature, None).map(_.value.toLong))
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/TweetTimeFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.home_mixer.model.HomeFeatures.EarlybirdFeature
import com.twitter.home_mixer.model.HomeFeatures.NonPollingTimesFeature
import com.twitter.home_mixer.model.HomeFeatures.SourceTweetIdFeature
import com.twitter.ml.api.DataRecord
import com.twitter.ml.api.util.FDsl._
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.CandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.snowflake.id.SnowflakeId
import com.twitter.stitch.Stitch
import com.twitter.timelines.prediction.features.time_features.TimeDataRecordFeatures._
import com.twitter.util.Duration
import scala.collection.Searching._
object TweetTimeDataRecordFeature
extends DataRecordInAFeature[TweetCandidate]
with FeatureWithDefaultOnFailure[TweetCandidate, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
object TweetTimeFeatureHydrator extends CandidateFeatureHydrator[PipelineQuery, TweetCandidate] {
override val identifier: FeatureHydratorIdentifier = FeatureHydratorIdentifier("TweetTime")
override val features: Set[Feature[_, _]] = Set(TweetTimeDataRecordFeature)
override def apply(
query: PipelineQuery,
candidate: TweetCandidate,
existingFeatures: FeatureMap
): Stitch[FeatureMap] = {
val tweetFeatures = existingFeatures.getOrElse(EarlybirdFeature, None)
val timeSinceTweetCreation = SnowflakeId.timeFromIdOpt(candidate.id).map(query.queryTime.since)
val timeSinceTweetCreationMs = timeSinceTweetCreation.map(_.inMillis)
val timeSinceSourceTweetCreationOpt = existingFeatures
.getOrElse(SourceTweetIdFeature, None)
.flatMap { sourceTweetId =>
SnowflakeId.timeFromIdOpt(sourceTweetId).map(query.queryTime.since)
}.orElse(timeSinceTweetCreation)
val lastFavSinceCreationHrs =
tweetFeatures.flatMap(_.lastFavSinceCreationHrs).map(_.toDouble)
val lastRetweetSinceCreationHrs =
tweetFeatures.flatMap(_.lastRetweetSinceCreationHrs).map(_.toDouble)
val lastReplySinceCreationHrs =
tweetFeatures.flatMap(_.lastReplySinceCreationHrs).map(_.toDouble)
val lastQuoteSinceCreationHrs =
tweetFeatures.flatMap(_.lastQuoteSinceCreationHrs).map(_.toDouble)
val timeSinceLastFavoriteHrs =
getTimeSinceLastEngagementHrs(lastFavSinceCreationHrs, timeSinceSourceTweetCreationOpt)
val timeSinceLastRetweetHrs =
getTimeSinceLastEngagementHrs(lastRetweetSinceCreationHrs, timeSinceSourceTweetCreationOpt)
val timeSinceLastReplyHrs =
getTimeSinceLastEngagementHrs(lastReplySinceCreationHrs, timeSinceSourceTweetCreationOpt)
val timeSinceLastQuoteHrs =
getTimeSinceLastEngagementHrs(lastQuoteSinceCreationHrs, timeSinceSourceTweetCreationOpt)
val nonPollingTimestampsMs = query.features.get.getOrElse(NonPollingTimesFeature, Seq.empty)
val timeSinceLastNonPollingRequest =
nonPollingTimestampsMs.headOption.map(query.queryTime.inMillis - _)
val nonPollingRequestsSinceTweetCreation =
if (nonPollingTimestampsMs.nonEmpty && timeSinceTweetCreationMs.isDefined) {
nonPollingTimestampsMs
.search(timeSinceTweetCreationMs.get)(Ordering[Long].reverse)
.insertionPoint
} else 0.0
val tweetAgeRatio =
if (timeSinceTweetCreationMs.exists(_ > 0.0) && timeSinceLastNonPollingRequest.isDefined) {
timeSinceLastNonPollingRequest.get / timeSinceTweetCreationMs.get.toDouble
} else 0.0
val dataRecord = new DataRecord()
.setFeatureValue(IS_TWEET_RECYCLED, false)
.setFeatureValue(TWEET_AGE_RATIO, tweetAgeRatio)
.setFeatureValueFromOption(
TIME_SINCE_TWEET_CREATION,
timeSinceTweetCreationMs.map(_.toDouble)
)
.setFeatureValue(
NON_POLLING_REQUESTS_SINCE_TWEET_CREATION,
nonPollingRequestsSinceTweetCreation
)
.setFeatureValueFromOption(LAST_FAVORITE_SINCE_CREATION_HRS, lastFavSinceCreationHrs)
.setFeatureValueFromOption(LAST_RETWEET_SINCE_CREATION_HRS, lastRetweetSinceCreationHrs)
.setFeatureValueFromOption(LAST_REPLY_SINCE_CREATION_HRS, lastReplySinceCreationHrs)
.setFeatureValueFromOption(LAST_QUOTE_SINCE_CREATION_HRS, lastQuoteSinceCreationHrs)
.setFeatureValueFromOption(TIME_SINCE_LAST_FAVORITE_HRS, timeSinceLastFavoriteHrs)
.setFeatureValueFromOption(TIME_SINCE_LAST_RETWEET_HRS, timeSinceLastRetweetHrs)
.setFeatureValueFromOption(TIME_SINCE_LAST_REPLY_HRS, timeSinceLastReplyHrs)
.setFeatureValueFromOption(TIME_SINCE_LAST_QUOTE_HRS, timeSinceLastQuoteHrs)
Stitch.value(FeatureMapBuilder().add(TweetTimeDataRecordFeature, dataRecord).build())
}
private def getTimeSinceLastEngagementHrs(
lastEngagementTimeSinceCreationHrsOpt: Option[Double],
timeSinceTweetCreation: Option[Duration]
): Option[Double] = lastEngagementTimeSinceCreationHrsOpt.flatMap { lastEngagementTimeHrs =>
timeSinceTweetCreation.map(_.inHours - lastEngagementTimeHrs)
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/TweetypieContentFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.escherbird.{thriftscala => esb}
import com.twitter.finagle.stats.Stat
import com.twitter.finagle.stats.StatsReceiver
import com.twitter.home_mixer.model.HomeFeatures.MediaUnderstandingAnnotationIdsFeature
import com.twitter.home_mixer.model.HomeFeatures.SourceTweetIdFeature
import com.twitter.home_mixer.param.HomeMixerInjectionNames.TweetypieContentRepository
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.adapters.content.ContentFeatureAdapter
import com.twitter.home_mixer.util.ObservedKeyValueResultHandler
import com.twitter.home_mixer.util.tweetypie.content.FeatureExtractionHelper
import com.twitter.ml.api.DataRecord
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BulkCandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.util.OffloadFuturePools
import com.twitter.servo.keyvalue.KeyValueResult
import com.twitter.servo.repository.KeyValueRepository
import com.twitter.stitch.Stitch
import com.twitter.timelines.prediction.common.util.MediaUnderstandingAnnotations
import com.twitter.tweetypie.{thriftscala => tp}
import com.twitter.util.Future
import com.twitter.util.Return
import com.twitter.util.Throw
import com.twitter.util.Try
import javax.inject.Inject
import javax.inject.Named
import javax.inject.Singleton
import scala.collection.JavaConverters._
object TweetypieContentDataRecordFeature
extends DataRecordInAFeature[TweetCandidate]
with FeatureWithDefaultOnFailure[TweetCandidate, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
@Singleton
class TweetypieContentFeatureHydrator @Inject() (
@Named(TweetypieContentRepository) client: KeyValueRepository[Seq[Long], Long, tp.Tweet],
override val statsReceiver: StatsReceiver)
extends BulkCandidateFeatureHydrator[PipelineQuery, TweetCandidate]
with ObservedKeyValueResultHandler {
override val identifier: FeatureHydratorIdentifier = FeatureHydratorIdentifier("TweetypieContent")
override val features: Set[Feature[_, _]] = Set(
MediaUnderstandingAnnotationIdsFeature,
TweetypieContentDataRecordFeature
)
override val statScope: String = identifier.toString
private val bulkRequestLatencyStat =
statsReceiver.scope(statScope).scope("bulkRequest").stat("latency_ms")
private val postTransformerLatencyStat =
statsReceiver.scope(statScope).scope("postTransformer").stat("latency_ms")
private val bulkPostTransformerLatencyStat =
statsReceiver.scope(statScope).scope("bulkPostTransformer").stat("latency_ms")
private val DefaultDataRecord: DataRecord = new DataRecord()
override def apply(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Stitch[Seq[FeatureMap]] = OffloadFuturePools.offloadFuture {
val tweetIdsToHydrate = candidates.map(getCandidateOriginalTweetId).distinct
val response: Future[KeyValueResult[Long, tp.Tweet]] = Stat.timeFuture(bulkRequestLatencyStat) {
if (tweetIdsToHydrate.isEmpty) Future.value(KeyValueResult.empty)
else client(tweetIdsToHydrate)
}
response.flatMap { result =>
Stat.timeFuture(bulkPostTransformerLatencyStat) {
OffloadFuturePools
.parallelize[CandidateWithFeatures[TweetCandidate], Try[(Seq[Long], DataRecord)]](
candidates,
parTransformer(result, _),
parallelism = 32,
default = Return((Seq.empty, DefaultDataRecord))
).map {
_.map {
case Return(result) =>
FeatureMapBuilder()
.add(MediaUnderstandingAnnotationIdsFeature, result._1)
.add(TweetypieContentDataRecordFeature, result._2)
.build()
case Throw(e) =>
FeatureMapBuilder()
.add(MediaUnderstandingAnnotationIdsFeature, Throw(e))
.add(TweetypieContentDataRecordFeature, Throw(e))
.build()
}
}
}
}
}
private def parTransformer(
result: KeyValueResult[Long, tp.Tweet],
candidate: CandidateWithFeatures[TweetCandidate]
): Try[(Seq[Long], DataRecord)] = {
val originalTweetId = Some(getCandidateOriginalTweetId(candidate))
val value = observedGet(key = originalTweetId, keyValueResult = result)
Stat.time(postTransformerLatencyStat)(postTransformer(value))
}
private def postTransformer(
result: Try[Option[tp.Tweet]]
): Try[(Seq[Long], DataRecord)] = {
result.map { tweet =>
val transformedValue = tweet.map(FeatureExtractionHelper.extractFeatures)
val semanticAnnotations = transformedValue
.flatMap { contentFeatures =>
contentFeatures.semanticCoreAnnotations.map {
getNonSensitiveHighRecallMediaUnderstandingAnnotationEntityIds
}
}.getOrElse(Seq.empty)
val dataRecord = ContentFeatureAdapter.adaptToDataRecords(transformedValue).asScala.head
(semanticAnnotations, dataRecord)
}
}
private def getCandidateOriginalTweetId(
candidate: CandidateWithFeatures[TweetCandidate]
): Long = {
candidate.features
.getOrElse(SourceTweetIdFeature, None).getOrElse(candidate.candidate.id)
}
private def getNonSensitiveHighRecallMediaUnderstandingAnnotationEntityIds(
semanticCoreAnnotations: Seq[esb.TweetEntityAnnotation]
): Seq[Long] =
semanticCoreAnnotations
.filter(MediaUnderstandingAnnotations.isEligibleNonSensitiveHighRecallMUAnnotation)
.map(_.entityId)
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/TweetypieStaticEntitiesFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.google.inject.name.Named
import com.twitter.conversions.DurationOps.RichDuration
import com.twitter.home_mixer.model.HomeFeatures.AuthorIdFeature
import com.twitter.home_mixer.model.HomeFeatures.DirectedAtUserIdFeature
import com.twitter.home_mixer.model.HomeFeatures.ExclusiveConversationAuthorIdFeature
import com.twitter.home_mixer.model.HomeFeatures.HasImageFeature
import com.twitter.home_mixer.model.HomeFeatures.HasVideoFeature
import com.twitter.home_mixer.model.HomeFeatures.InReplyToTweetIdFeature
import com.twitter.home_mixer.model.HomeFeatures.InReplyToUserIdFeature
import com.twitter.home_mixer.model.HomeFeatures.IsRetweetFeature
import com.twitter.home_mixer.model.HomeFeatures.MentionScreenNameFeature
import com.twitter.home_mixer.model.HomeFeatures.MentionUserIdFeature
import com.twitter.home_mixer.model.HomeFeatures.QuotedTweetIdFeature
import com.twitter.home_mixer.model.HomeFeatures.QuotedUserIdFeature
import com.twitter.home_mixer.model.HomeFeatures.SourceTweetIdFeature
import com.twitter.home_mixer.model.HomeFeatures.SourceUserIdFeature
import com.twitter.home_mixer.param.HomeMixerInjectionNames.TweetypieStaticEntitiesCache
import com.twitter.home_mixer.util.tweetypie.RequestFields
import com.twitter.home_mixer.util.tweetypie.content.TweetMediaFeaturesExtractor
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BulkCandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.servo.cache.TtlCache
import com.twitter.spam.rtf.{thriftscala => sp}
import com.twitter.stitch.Stitch
import com.twitter.stitch.tweetypie.{TweetyPie => TweetypieStitchClient}
import com.twitter.tweetypie.{thriftscala => tp}
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class TweetypieStaticEntitiesFeatureHydrator @Inject() (
tweetypieStitchClient: TweetypieStitchClient,
@Named(TweetypieStaticEntitiesCache) cacheClient: TtlCache[Long, tp.Tweet])
extends BulkCandidateFeatureHydrator[PipelineQuery, TweetCandidate] {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("TweetypieStaticEntities")
override val features: Set[Feature[_, _]] = Set(
AuthorIdFeature,
DirectedAtUserIdFeature,
ExclusiveConversationAuthorIdFeature,
HasImageFeature,
HasVideoFeature,
InReplyToTweetIdFeature,
InReplyToUserIdFeature,
IsRetweetFeature,
MentionScreenNameFeature,
MentionUserIdFeature,
QuotedTweetIdFeature,
QuotedUserIdFeature,
SourceTweetIdFeature,
SourceUserIdFeature
)
private val CacheTTL = 24.hours
private val DefaultFeatureMap = FeatureMapBuilder()
.add(AuthorIdFeature, None)
.add(DirectedAtUserIdFeature, None)
.add(ExclusiveConversationAuthorIdFeature, None)
.add(HasImageFeature, false)
.add(HasVideoFeature, false)
.add(InReplyToTweetIdFeature, None)
.add(InReplyToUserIdFeature, None)
.add(IsRetweetFeature, false)
.add(MentionScreenNameFeature, Seq.empty)
.add(MentionUserIdFeature, Seq.empty)
.add(QuotedTweetIdFeature, None)
.add(QuotedUserIdFeature, None)
.add(SourceTweetIdFeature, None)
.add(SourceUserIdFeature, None)
.build()
/**
* Steps:
* 1. query cache with all candidates
* 2. create a cached feature map
* 3. iterate candidates to hydrate features
* 3.a transform cached candidates
* 3.b hydrate non-cached candidates from Tweetypie and write to cache
*/
override def apply(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Stitch[Seq[FeatureMap]] = {
val tweetIds = candidates.map(_.candidate.id)
val cachedTweetsMapFu = cacheClient
.get(tweetIds)
.map(_.found)
Stitch.callFuture(cachedTweetsMapFu).flatMap { cachedTweets =>
Stitch.collect {
candidates.map { candidate =>
if (cachedTweets.contains(candidate.candidate.id))
Stitch.value(createFeatureMap(cachedTweets(candidate.candidate.id)))
else readFromTweetypie(query, candidate)
}
}
}
}
private def createFeatureMap(tweet: tp.Tweet): FeatureMap = {
val coreData = tweet.coreData
val quotedTweet = tweet.quotedTweet
val mentions = tweet.mentions.getOrElse(Seq.empty)
val share = coreData.flatMap(_.share)
val reply = coreData.flatMap(_.reply)
FeatureMapBuilder()
.add(AuthorIdFeature, coreData.map(_.userId))
.add(DirectedAtUserIdFeature, coreData.flatMap(_.directedAtUser.map(_.userId)))
.add(
ExclusiveConversationAuthorIdFeature,
tweet.exclusiveTweetControl.map(_.conversationAuthorId))
.add(HasImageFeature, TweetMediaFeaturesExtractor.hasImage(tweet))
.add(HasVideoFeature, TweetMediaFeaturesExtractor.hasVideo(tweet))
.add(InReplyToTweetIdFeature, reply.flatMap(_.inReplyToStatusId))
.add(InReplyToUserIdFeature, reply.map(_.inReplyToUserId))
.add(IsRetweetFeature, share.isDefined)
.add(MentionScreenNameFeature, mentions.map(_.screenName))
.add(MentionUserIdFeature, mentions.flatMap(_.userId))
.add(QuotedTweetIdFeature, quotedTweet.map(_.tweetId))
.add(QuotedUserIdFeature, quotedTweet.map(_.userId))
.add(SourceTweetIdFeature, share.map(_.sourceStatusId))
.add(SourceUserIdFeature, share.map(_.sourceUserId))
.build()
}
private def readFromTweetypie(
query: PipelineQuery,
candidate: CandidateWithFeatures[TweetCandidate]
): Stitch[FeatureMap] = {
tweetypieStitchClient
.getTweetFields(
tweetId = candidate.candidate.id,
options = tp.GetTweetFieldsOptions(
tweetIncludes = RequestFields.TweetStaticEntitiesFields,
includeRetweetedTweet = false,
includeQuotedTweet = false,
forUserId = query.getOptionalUserId, // Needed to get protected Tweets for certain users
visibilityPolicy = tp.TweetVisibilityPolicy.UserVisible,
safetyLevel = Some(sp.SafetyLevel.FilterNone) // VF is handled in the For You product
)
).map {
case tp.GetTweetFieldsResult(_, tp.TweetFieldsResultState.Found(found), _, _) =>
cacheClient.set(candidate.candidate.id, found.tweet, CacheTTL)
createFeatureMap(found.tweet)
case _ =>
DefaultFeatureMap + (AuthorIdFeature, candidate.features.getOrElse(AuthorIdFeature, None))
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/TwhinAuthorFollowFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.finagle.stats.StatsReceiver
import com.twitter.home_mixer.param.HomeMixerInjectionNames.TwhinAuthorFollowFeatureRepository
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.adapters.twhin_embeddings.TwhinAuthorFollowEmbeddingsAdapter
import com.twitter.home_mixer.util.CandidatesUtil
import com.twitter.home_mixer.util.ObservedKeyValueResultHandler
import com.twitter.ml.api.DataRecord
import com.twitter.ml.api.{thriftscala => ml}
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BulkCandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.util.OffloadFuturePools
import com.twitter.servo.repository.KeyValueRepository
import com.twitter.servo.repository.KeyValueResult
import com.twitter.stitch.Stitch
import com.twitter.util.Future
import com.twitter.util.Try
import javax.inject.Inject
import javax.inject.Named
import javax.inject.Singleton
import scala.collection.JavaConverters._
object TwhinAuthorFollowFeature
extends DataRecordInAFeature[TweetCandidate]
with FeatureWithDefaultOnFailure[TweetCandidate, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
@Singleton
class TwhinAuthorFollowFeatureHydrator @Inject() (
@Named(TwhinAuthorFollowFeatureRepository)
client: KeyValueRepository[Seq[Long], Long, ml.FloatTensor],
override val statsReceiver: StatsReceiver)
extends BulkCandidateFeatureHydrator[PipelineQuery, TweetCandidate]
with ObservedKeyValueResultHandler {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("TwhinAuthorFollow")
override val features: Set[Feature[_, _]] = Set(TwhinAuthorFollowFeature)
override val statScope: String = identifier.toString
override def apply(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Stitch[Seq[FeatureMap]] = OffloadFuturePools.offloadFuture {
val possiblyAuthorIds = extractKeys(candidates)
val authorIds = possiblyAuthorIds.flatten
val response: Future[KeyValueResult[Long, ml.FloatTensor]] =
if (authorIds.isEmpty) Future.value(KeyValueResult.empty) else client(authorIds)
response.map { result =>
possiblyAuthorIds.map { possiblyAuthorId =>
val value = observedGet(key = possiblyAuthorId, keyValueResult = result)
val transformedValue = postTransformer(value)
FeatureMapBuilder().add(TwhinAuthorFollowFeature, transformedValue).build()
}
}
}
private def postTransformer(embedding: Try[Option[ml.FloatTensor]]): Try[DataRecord] = {
embedding.map { floatTensor =>
TwhinAuthorFollowEmbeddingsAdapter.adaptToDataRecords(floatTensor).asScala.head
}
}
private def extractKeys(
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Seq[Option[Long]] = {
candidates.map { candidate =>
CandidatesUtil.getOriginalAuthorId(candidate.features)
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/TwhinUserEngagementQueryFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.finagle.stats.StatsReceiver
import com.twitter.home_mixer.param.HomeMixerInjectionNames.TwhinUserEngagementFeatureRepository
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.adapters.twhin_embeddings.TwhinUserEngagementEmbeddingsAdapter
import com.twitter.ml.api.DataRecord
import com.twitter.ml.api.{thriftscala => ml}
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.QueryFeatureHydrator
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.servo.repository.KeyValueRepository
import com.twitter.stitch.Stitch
import com.twitter.util.Return
import com.twitter.util.Throw
import javax.inject.Inject
import javax.inject.Named
import javax.inject.Singleton
import scala.collection.JavaConverters._
object TwhinUserEngagementFeature
extends DataRecordInAFeature[PipelineQuery]
with FeatureWithDefaultOnFailure[PipelineQuery, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
@Singleton
class TwhinUserEngagementQueryFeatureHydrator @Inject() (
@Named(TwhinUserEngagementFeatureRepository)
client: KeyValueRepository[Seq[Long], Long, ml.FloatTensor],
statsReceiver: StatsReceiver)
extends QueryFeatureHydrator[PipelineQuery] {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("TwhinUserEngagement")
override val features: Set[Feature[_, _]] = Set(TwhinUserEngagementFeature)
private val scopedStatsReceiver = statsReceiver.scope(getClass.getSimpleName)
private val keyFoundCounter = scopedStatsReceiver.counter("key/found")
private val keyLossCounter = scopedStatsReceiver.counter("key/loss")
private val keyFailureCounter = scopedStatsReceiver.counter("key/failure")
override def hydrate(query: PipelineQuery): Stitch[FeatureMap] = {
val userId = query.getRequiredUserId
Stitch.callFuture(client(Seq(userId))).map { results =>
val embedding: Option[ml.FloatTensor] = results(userId) match {
case Return(value) =>
if (value.exists(_.floats.nonEmpty)) keyFoundCounter.incr()
else keyLossCounter.incr()
value
case Throw(_) =>
keyFailureCounter.incr()
None
case _ =>
None
}
val dataRecord =
TwhinUserEngagementEmbeddingsAdapter.adaptToDataRecords(embedding).asScala.head
FeatureMapBuilder()
.add(TwhinUserEngagementFeature, dataRecord)
.build()
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/TwhinUserFollowQueryFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.finagle.stats.StatsReceiver
import com.twitter.home_mixer.param.HomeMixerInjectionNames.TwhinUserFollowFeatureRepository
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.adapters.twhin_embeddings.TwhinUserFollowEmbeddingsAdapter
import com.twitter.ml.api.DataRecord
import com.twitter.ml.api.{thriftscala => ml}
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.QueryFeatureHydrator
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.servo.repository.KeyValueRepository
import com.twitter.stitch.Stitch
import com.twitter.util.Return
import com.twitter.util.Throw
import javax.inject.Inject
import javax.inject.Named
import javax.inject.Singleton
import scala.collection.JavaConverters._
object TwhinUserFollowFeature
extends DataRecordInAFeature[PipelineQuery]
with FeatureWithDefaultOnFailure[PipelineQuery, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
@Singleton
class TwhinUserFollowQueryFeatureHydrator @Inject() (
@Named(TwhinUserFollowFeatureRepository)
client: KeyValueRepository[Seq[Long], Long, ml.FloatTensor],
statsReceiver: StatsReceiver)
extends QueryFeatureHydrator[PipelineQuery] {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("TwhinUserFollow")
override val features: Set[Feature[_, _]] = Set(TwhinUserFollowFeature)
private val scopedStatsReceiver = statsReceiver.scope(getClass.getSimpleName)
private val keyFoundCounter = scopedStatsReceiver.counter("key/found")
private val keyLossCounter = scopedStatsReceiver.counter("key/loss")
private val keyFailureCounter = scopedStatsReceiver.counter("key/failure")
override def hydrate(query: PipelineQuery): Stitch[FeatureMap] = {
val userId = query.getRequiredUserId
Stitch.callFuture(client(Seq(userId))).map { results =>
val embedding: Option[ml.FloatTensor] = results(userId) match {
case Return(value) =>
if (value.exists(_.floats.nonEmpty)) keyFoundCounter.incr()
else keyLossCounter.incr()
value
case Throw(_) =>
keyFailureCounter.incr()
None
case _ =>
None
}
val dataRecord = TwhinUserFollowEmbeddingsAdapter.adaptToDataRecords(embedding).asScala.head
FeatureMapBuilder()
.add(TwhinUserFollowFeature, dataRecord)
.build()
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/UserFollowedTopicIdsFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.finagle.stats.StatsReceiver
import com.twitter.home_mixer.model.HomeFeatures.AuthorIdFeature
import com.twitter.home_mixer.param.HomeMixerInjectionNames.UserFollowedTopicIdsRepository
import com.twitter.home_mixer.util.ObservedKeyValueResultHandler
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BulkCandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.util.OffloadFuturePools
import com.twitter.servo.keyvalue.KeyValueResult
import com.twitter.servo.repository.KeyValueRepository
import com.twitter.stitch.Stitch
import com.twitter.util.Future
import com.twitter.util.Try
import javax.inject.Inject
import javax.inject.Named
import javax.inject.Singleton
object UserFollowedTopicIdsFeature extends Feature[TweetCandidate, Seq[Long]]
@Singleton
class UserFollowedTopicIdsFeatureHydrator @Inject() (
@Named(UserFollowedTopicIdsRepository)
client: KeyValueRepository[Seq[Long], Long, Seq[Long]],
override val statsReceiver: StatsReceiver)
extends BulkCandidateFeatureHydrator[PipelineQuery, TweetCandidate]
with ObservedKeyValueResultHandler {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("UserFollowedTopicIds")
override val features: Set[Feature[_, _]] = Set(UserFollowedTopicIdsFeature)
override val statScope: String = identifier.toString
override def apply(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Stitch[Seq[FeatureMap]] = OffloadFuturePools.offloadFuture {
val possiblyAuthorIds = extractKeys(candidates)
val authorIds = possiblyAuthorIds.flatten
val response: Future[KeyValueResult[Long, Seq[Long]]] =
if (authorIds.isEmpty) Future.value(KeyValueResult.empty) else client(authorIds)
response.map { result =>
possiblyAuthorIds.map { possiblyAuthorId =>
val value = observedGet(key = possiblyAuthorId, keyValueResult = result)
val transformedValue = postTransformer(value)
FeatureMapBuilder().add(UserFollowedTopicIdsFeature, transformedValue).build()
}
}
}
private def postTransformer(input: Try[Option[Seq[Long]]]): Try[Seq[Long]] = {
input.map(_.getOrElse(Seq.empty[Long]))
}
private def extractKeys(
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Seq[Option[Long]] = {
candidates.map { candidate =>
candidate.features
.getTry(AuthorIdFeature)
.toOption
.flatten
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/UserLanguagesFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.finagle.stats.StatsReceiver
import com.twitter.home_mixer.param.HomeMixerInjectionNames.UserLanguagesRepository
import com.twitter.home_mixer.util.ObservedKeyValueResultHandler
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.QueryFeatureHydrator
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.search.common.constants.{thriftscala => scc}
import com.twitter.servo.repository.KeyValueRepository
import com.twitter.stitch.Stitch
import javax.inject.Inject
import javax.inject.Named
import javax.inject.Singleton
object UserLanguagesFeature extends Feature[PipelineQuery, Seq[scc.ThriftLanguage]]
@Singleton
case class UserLanguagesFeatureHydrator @Inject() (
@Named(UserLanguagesRepository) client: KeyValueRepository[Seq[Long], Long, Seq[
scc.ThriftLanguage
]],
statsReceiver: StatsReceiver)
extends QueryFeatureHydrator[PipelineQuery]
with ObservedKeyValueResultHandler {
override val identifier: FeatureHydratorIdentifier = FeatureHydratorIdentifier("UserLanguages")
override val features: Set[Feature[_, _]] = Set(UserLanguagesFeature)
override val statScope: String = identifier.toString
override def hydrate(query: PipelineQuery): Stitch[FeatureMap] = {
val key = query.getRequiredUserId
Stitch.callFuture(client(Seq(key))).map { result =>
val feature =
observedGet(key = Some(key), keyValueResult = result).map(_.getOrElse(Seq.empty))
FeatureMapBuilder()
.add(UserLanguagesFeature, feature)
.build()
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/UserStateQueryFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.home_mixer.model.HomeFeatures.UserStateFeature
import com.twitter.home_mixer.service.HomeMixerAlertConfig
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.QueryFeatureHydrator
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.stitch.Stitch
import com.twitter.timelines.user_health.v1.{thriftscala => uhv1}
import com.twitter.timelines.user_health.{thriftscala => uh}
import com.twitter.user_session_store.ReadOnlyUserSessionStore
import com.twitter.user_session_store.ReadRequest
import com.twitter.user_session_store.UserSessionDataset
import com.twitter.user_session_store.UserSessionDataset.UserSessionDataset
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
case class UserStateQueryFeatureHydrator @Inject() (
userSessionStore: ReadOnlyUserSessionStore)
extends QueryFeatureHydrator[PipelineQuery] {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("UserState")
override val features: Set[Feature[_, _]] = Set(UserStateFeature)
private val datasets: Set[UserSessionDataset] = Set(UserSessionDataset.UserHealth)
override def hydrate(query: PipelineQuery): Stitch[FeatureMap] = {
userSessionStore
.read(ReadRequest(query.getRequiredUserId, datasets))
.map { userSession =>
val userState = userSession.flatMap {
_.userHealth match {
case Some(uh.UserHealth.V1(uhv1.UserHealth(userState))) => userState
case _ => None
}
}
FeatureMapBuilder()
.add(UserStateFeature, userState)
.build()
}
}
override val alerts = Seq(
HomeMixerAlertConfig.BusinessHours.defaultSuccessRateAlert(99.9)
)
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/UtegFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator
import com.twitter.home_mixer.model.HomeFeatures.FavoritedByCountFeature
import com.twitter.home_mixer.model.HomeFeatures.FavoritedByUserIdsFeature
import com.twitter.home_mixer.model.HomeFeatures.FromInNetworkSourceFeature
import com.twitter.home_mixer.model.HomeFeatures.InReplyToTweetIdFeature
import com.twitter.home_mixer.model.HomeFeatures.RealGraphInNetworkScoresFeature
import com.twitter.home_mixer.model.HomeFeatures.RepliedByCountFeature
import com.twitter.home_mixer.model.HomeFeatures.RepliedByEngagerIdsFeature
import com.twitter.home_mixer.model.HomeFeatures.RetweetedByCountFeature
import com.twitter.home_mixer.model.HomeFeatures.RetweetedByEngagerIdsFeature
import com.twitter.home_mixer.model.HomeFeatures.SourceTweetIdFeature
import com.twitter.home_mixer.param.HomeMixerInjectionNames.UtegSocialProofRepository
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BulkCandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.Conditionally
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.util.OffloadFuturePools
import com.twitter.recos.recos_common.{thriftscala => rc}
import com.twitter.recos.user_tweet_entity_graph.{thriftscala => uteg}
import com.twitter.servo.keyvalue.KeyValueResult
import com.twitter.servo.repository.KeyValueRepository
import com.twitter.stitch.Stitch
import javax.inject.Inject
import javax.inject.Named
import javax.inject.Singleton
@Singleton
class UtegFeatureHydrator @Inject() (
@Named(UtegSocialProofRepository) client: KeyValueRepository[
(Seq[Long], (Long, Map[Long, Double])),
Long,
uteg.TweetRecommendation
]) extends BulkCandidateFeatureHydrator[PipelineQuery, TweetCandidate]
with Conditionally[PipelineQuery] {
override val identifier: FeatureHydratorIdentifier = FeatureHydratorIdentifier("Uteg")
override val features: Set[Feature[_, _]] = Set(
FavoritedByUserIdsFeature,
RetweetedByEngagerIdsFeature,
RepliedByEngagerIdsFeature,
FavoritedByCountFeature,
RetweetedByCountFeature,
RepliedByCountFeature
)
override def onlyIf(query: PipelineQuery): Boolean = query.features
.exists(_.getOrElse(RealGraphInNetworkScoresFeature, Map.empty[Long, Double]).nonEmpty)
override def apply(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Stitch[Seq[FeatureMap]] = OffloadFuturePools.offloadFuture {
val seedUserWeights = query.features.map(_.get(RealGraphInNetworkScoresFeature)).get
val sourceTweetIds = candidates.flatMap(_.features.getOrElse(SourceTweetIdFeature, None))
val inReplyToTweetIds = candidates.flatMap(_.features.getOrElse(InReplyToTweetIdFeature, None))
val tweetIds = candidates.map(_.candidate.id)
val tweetIdsToSend = (tweetIds ++ sourceTweetIds ++ inReplyToTweetIds).distinct
val utegQuery = (tweetIdsToSend, (query.getRequiredUserId, seedUserWeights))
client(utegQuery).map(handleResponse(candidates, _))
}
private def handleResponse(
candidates: Seq[CandidateWithFeatures[TweetCandidate]],
results: KeyValueResult[Long, uteg.TweetRecommendation],
): Seq[FeatureMap] = {
candidates.map { candidate =>
val inNetwork = candidate.features.getOrElse(FromInNetworkSourceFeature, false)
val candidateProof = results(candidate.candidate.id).toOption.flatten
val sourceProof = candidate.features
.getOrElse(SourceTweetIdFeature, None).flatMap(results(_).toOption.flatten)
val proofs = Seq(candidateProof, sourceProof).flatten.map(_.socialProofByType)
val favoritedBy = proofs.flatMap(_.get(rc.SocialProofType.Favorite)).flatten
val retweetedBy = proofs.flatMap(_.get(rc.SocialProofType.Retweet)).flatten
val repliedBy = proofs.flatMap(_.get(rc.SocialProofType.Reply)).flatten
val (favoritedByCount, retweetedByCount, repliedByCount) =
if (!inNetwork) {
(favoritedBy.size.toDouble, retweetedBy.size.toDouble, repliedBy.size.toDouble)
} else { (0.0, 0.0, 0.0) }
FeatureMapBuilder()
.add(FavoritedByUserIdsFeature, favoritedBy)
.add(RetweetedByEngagerIdsFeature, retweetedBy)
.add(RepliedByEngagerIdsFeature, repliedBy)
.add(FavoritedByCountFeature, favoritedByCount)
.add(RetweetedByCountFeature, retweetedByCount)
.add(RepliedByCountFeature, repliedByCount)
.build()
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/author_features/AuthorFeaturesAdapter.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.adapters.author_features
import com.twitter.home_mixer.util.DataRecordUtil
import com.twitter.ml.api.DataRecord
import com.twitter.ml.api.Feature
import com.twitter.ml.api.FeatureContext
import com.twitter.ml.api.util.CompactDataRecordConverter
import com.twitter.ml.api.util.FDsl._
import com.twitter.timelines.author_features.v1.{thriftjava => af}
import com.twitter.timelines.prediction.common.adapters.TimelinesAdapterBase
import com.twitter.timelines.prediction.common.aggregates.TimelinesAggregationConfig
import com.twitter.timelines.prediction.features.user_health.UserHealthFeatures
import scala.collection.JavaConverters._
object AuthorFeaturesAdapter extends TimelinesAdapterBase[af.AuthorFeatures] {
private val Prefix = "original_author.timelines.original_author_aggregates."
private val typedAggregateGroups =
TimelinesAggregationConfig.originalAuthorAggregatesV1.buildTypedAggregateGroups()
private val aggregateFeaturesRenameMap: Map[Feature[_], Feature[_]] =
typedAggregateGroups.map(_.outputFeaturesToRenamedOutputFeatures(Prefix)).reduce(_ ++ _)
private val prefixedOriginalAuthorAggregateFeatures =
typedAggregateGroups.flatMap(_.allOutputFeatures).map { feature =>
aggregateFeaturesRenameMap.getOrElse(feature, feature)
}
private val authorFeatures = prefixedOriginalAuthorAggregateFeatures ++ Seq(
UserHealthFeatures.AuthorState,
UserHealthFeatures.NumAuthorFollowers,
UserHealthFeatures.NumAuthorConnectDays,
UserHealthFeatures.NumAuthorConnect
)
private val aggregateFeatureContext: FeatureContext =
new FeatureContext(typedAggregateGroups.flatMap(_.allOutputFeatures).asJava)
private lazy val prefixedAggregateFeatureContext: FeatureContext =
new FeatureContext(prefixedOriginalAuthorAggregateFeatures.asJava)
override val getFeatureContext: FeatureContext = new FeatureContext(authorFeatures: _*)
override val commonFeatures: Set[Feature[_]] = Set.empty
private val compactDataRecordConverter = new CompactDataRecordConverter()
override def adaptToDataRecords(
authorFeatures: af.AuthorFeatures
): java.util.List[DataRecord] = {
val dataRecord =
if (authorFeatures.aggregates != null) {
val originalAuthorAggregatesDataRecord =
compactDataRecordConverter.compactDataRecordToDataRecord(authorFeatures.aggregates)
DataRecordUtil.applyRename(
originalAuthorAggregatesDataRecord,
aggregateFeatureContext,
prefixedAggregateFeatureContext,
aggregateFeaturesRenameMap)
} else new DataRecord
if (authorFeatures.user_health != null) {
val userHealth = authorFeatures.user_health
if (userHealth.user_state != null) {
dataRecord.setFeatureValue(
UserHealthFeatures.AuthorState,
userHealth.user_state.getValue.toLong
)
}
dataRecord.setFeatureValue(
UserHealthFeatures.NumAuthorFollowers,
userHealth.num_followers.toDouble
)
dataRecord.setFeatureValue(
UserHealthFeatures.NumAuthorConnectDays,
userHealth.num_connect_days.toDouble
)
dataRecord.setFeatureValue(
UserHealthFeatures.NumAuthorConnect,
userHealth.num_connect.toDouble
)
}
List(dataRecord).asJava
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/author_features/BUILD.bazel | scala_library(
sources = ["*.scala"],
compiler_option_sets = ["fatal_warnings"],
strict_deps = True,
tags = ["bazel-compatible"],
dependencies = [
"home-mixer/server/src/main/scala/com/twitter/home_mixer/util",
"src/java/com/twitter/ml/api:api-base",
"src/java/com/twitter/ml/api/util",
"src/scala/com/twitter/ml/api/util",
"src/scala/com/twitter/timelines/prediction/common/adapters:base",
"src/scala/com/twitter/timelines/prediction/common/aggregates",
"src/scala/com/twitter/timelines/prediction/features/user_health",
"src/thrift/com/twitter/ml/api:data-java",
"src/thrift/com/twitter/timelines/author_features:thrift-java",
"timelines/data_processing/ml_util/aggregation_framework",
],
)
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/content/BUILD.bazel | scala_library(
sources = ["*.scala"],
compiler_option_sets = ["fatal_warnings"],
strict_deps = True,
tags = ["bazel-compatible"],
dependencies = [
"home-mixer/server/src/main/scala/com/twitter/home_mixer/model",
"src/java/com/twitter/ml/api:api-base",
"src/scala/com/twitter/ml/api:api-base",
"src/scala/com/twitter/ml/api/util",
"src/scala/com/twitter/timelines/prediction/common/adapters",
"src/scala/com/twitter/timelines/prediction/common/adapters:base",
"src/scala/com/twitter/timelines/prediction/features/common",
"src/scala/com/twitter/timelines/prediction/features/conversation_features",
"src/thrift/com/twitter/ml/api:data-java",
"src/thrift/com/twitter/ml/api:data-scala",
],
)
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/content/ContentFeatureAdapter.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.adapters.content
import com.twitter.home_mixer.model.ContentFeatures
import com.twitter.ml.api.Feature
import com.twitter.ml.api.FeatureContext
import com.twitter.ml.api.RichDataRecord
import com.twitter.ml.api.util.DataRecordConverters._
import com.twitter.timelines.prediction.common.adapters.TimelinesMutatingAdapterBase
import com.twitter.timelines.prediction.common.adapters.TweetLengthType
import com.twitter.timelines.prediction.features.common.TimelinesSharedFeatures
import com.twitter.timelines.prediction.features.conversation_features.ConversationFeatures
import scala.collection.JavaConverters._
object ContentFeatureAdapter extends TimelinesMutatingAdapterBase[Option[ContentFeatures]] {
override val getFeatureContext: FeatureContext = new FeatureContext(
ConversationFeatures.IS_SELF_THREAD_TWEET,
ConversationFeatures.IS_LEAF_IN_SELF_THREAD,
TimelinesSharedFeatures.ASPECT_RATIO_DEN,
TimelinesSharedFeatures.ASPECT_RATIO_NUM,
TimelinesSharedFeatures.BIT_RATE,
TimelinesSharedFeatures.CLASSIFICATION_LABELS,
TimelinesSharedFeatures.COLOR_1_BLUE,
TimelinesSharedFeatures.COLOR_1_GREEN,
TimelinesSharedFeatures.COLOR_1_PERCENTAGE,
TimelinesSharedFeatures.COLOR_1_RED,
TimelinesSharedFeatures.FACE_AREAS,
TimelinesSharedFeatures.HAS_APP_INSTALL_CALL_TO_ACTION,
TimelinesSharedFeatures.HAS_DESCRIPTION,
TimelinesSharedFeatures.HAS_QUESTION,
TimelinesSharedFeatures.HAS_SELECTED_PREVIEW_IMAGE,
TimelinesSharedFeatures.HAS_TITLE,
TimelinesSharedFeatures.HAS_VISIT_SITE_CALL_TO_ACTION,
TimelinesSharedFeatures.HAS_WATCH_NOW_CALL_TO_ACTION,
TimelinesSharedFeatures.HEIGHT_1,
TimelinesSharedFeatures.HEIGHT_2,
TimelinesSharedFeatures.HEIGHT_3,
TimelinesSharedFeatures.HEIGHT_4,
TimelinesSharedFeatures.IS_360,
TimelinesSharedFeatures.IS_EMBEDDABLE,
TimelinesSharedFeatures.IS_MANAGED,
TimelinesSharedFeatures.IS_MONETIZABLE,
TimelinesSharedFeatures.MEDIA_PROVIDERS,
TimelinesSharedFeatures.NUM_CAPS,
TimelinesSharedFeatures.NUM_COLOR_PALLETTE_ITEMS,
TimelinesSharedFeatures.NUM_FACES,
TimelinesSharedFeatures.NUM_MEDIA_TAGS,
TimelinesSharedFeatures.NUM_NEWLINES,
TimelinesSharedFeatures.NUM_STICKERS,
TimelinesSharedFeatures.NUM_WHITESPACES,
TimelinesSharedFeatures.RESIZE_METHOD_1,
TimelinesSharedFeatures.RESIZE_METHOD_2,
TimelinesSharedFeatures.RESIZE_METHOD_3,
TimelinesSharedFeatures.RESIZE_METHOD_4,
TimelinesSharedFeatures.TWEET_LENGTH,
TimelinesSharedFeatures.TWEET_LENGTH_TYPE,
TimelinesSharedFeatures.VIDEO_DURATION,
TimelinesSharedFeatures.VIEW_COUNT,
TimelinesSharedFeatures.WIDTH_1,
TimelinesSharedFeatures.WIDTH_2,
TimelinesSharedFeatures.WIDTH_3,
TimelinesSharedFeatures.WIDTH_4,
)
override val commonFeatures: Set[Feature[_]] = Set.empty
private def getTweetLengthType(tweetLength: Int): Long = {
tweetLength match {
case x if 0 > x || 280 < x => TweetLengthType.INVALID
case x if 0 <= x && x <= 30 => TweetLengthType.VERY_SHORT
case x if 30 < x && x <= 60 => TweetLengthType.SHORT
case x if 60 < x && x <= 90 => TweetLengthType.MEDIUM
case x if 90 < x && x <= 140 => TweetLengthType.LENGTHY
case x if 140 < x && x <= 210 => TweetLengthType.VERY_LENGTHY
case x if x > 210 => TweetLengthType.MAXIMUM_LENGTH
}
}
override def setFeatures(
contentFeatures: Option[ContentFeatures],
richDataRecord: RichDataRecord
): Unit = {
if (contentFeatures.nonEmpty) {
val features = contentFeatures.get
// Conversation Features
richDataRecord.setFeatureValueFromOption(
ConversationFeatures.IS_SELF_THREAD_TWEET,
Some(features.selfThreadMetadata.nonEmpty)
)
richDataRecord.setFeatureValueFromOption(
ConversationFeatures.IS_LEAF_IN_SELF_THREAD,
features.selfThreadMetadata.map(_.isLeaf)
)
// Media Features
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.ASPECT_RATIO_DEN,
features.aspectRatioDen.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.ASPECT_RATIO_NUM,
features.aspectRatioNum.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.BIT_RATE,
features.bitRate.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.HEIGHT_1,
features.heights.flatMap(_.lift(0)).map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.HEIGHT_2,
features.heights.flatMap(_.lift(1)).map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.HEIGHT_3,
features.heights.flatMap(_.lift(2)).map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.HEIGHT_4,
features.heights.flatMap(_.lift(3)).map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.NUM_MEDIA_TAGS,
features.numMediaTags.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.RESIZE_METHOD_1,
features.resizeMethods.flatMap(_.lift(0)).map(_.toLong)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.RESIZE_METHOD_2,
features.resizeMethods.flatMap(_.lift(1)).map(_.toLong)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.RESIZE_METHOD_3,
features.resizeMethods.flatMap(_.lift(2)).map(_.toLong)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.RESIZE_METHOD_4,
features.resizeMethods.flatMap(_.lift(3)).map(_.toLong)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.VIDEO_DURATION,
features.videoDurationMs.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.WIDTH_1,
features.widths.flatMap(_.lift(0)).map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.WIDTH_2,
features.widths.flatMap(_.lift(1)).map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.WIDTH_3,
features.widths.flatMap(_.lift(2)).map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.WIDTH_4,
features.widths.flatMap(_.lift(3)).map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.NUM_COLOR_PALLETTE_ITEMS,
features.numColors.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.COLOR_1_RED,
features.dominantColorRed.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.COLOR_1_BLUE,
features.dominantColorBlue.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.COLOR_1_GREEN,
features.dominantColorGreen.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.COLOR_1_PERCENTAGE,
features.dominantColorPercentage
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.MEDIA_PROVIDERS,
features.mediaOriginProviders.map(_.toSet.asJava)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.IS_360,
features.is360
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.VIEW_COUNT,
features.viewCount.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.IS_MANAGED,
features.isManaged
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.IS_MONETIZABLE,
features.isMonetizable
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.IS_EMBEDDABLE,
features.isEmbeddable
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.NUM_STICKERS,
features.stickerIds.map(_.length.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.NUM_FACES,
features.faceAreas.map(_.length.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.FACE_AREAS,
// guard for exception from max on empty seq
features.faceAreas.map(faceAreas =>
faceAreas.map(_.toDouble).reduceOption(_ max _).getOrElse(0.0))
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.HAS_SELECTED_PREVIEW_IMAGE,
features.hasSelectedPreviewImage
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.HAS_TITLE,
features.hasTitle
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.HAS_DESCRIPTION,
features.hasDescription
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.HAS_VISIT_SITE_CALL_TO_ACTION,
features.hasVisitSiteCallToAction
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.HAS_APP_INSTALL_CALL_TO_ACTION,
features.hasAppInstallCallToAction
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.HAS_WATCH_NOW_CALL_TO_ACTION,
features.hasWatchNowCallToAction
)
// text features
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.NUM_CAPS,
Some(features.numCaps.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.TWEET_LENGTH,
Some(features.length.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.TWEET_LENGTH_TYPE,
Some(getTweetLengthType(features.length.toInt))
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.NUM_WHITESPACES,
Some(features.numWhiteSpaces.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.HAS_QUESTION,
Some(features.hasQuestion)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.NUM_NEWLINES,
features.numNewlines.map(_.toDouble)
)
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/content/InReplyToContentFeatureAdapter.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.adapters.content
import com.twitter.home_mixer.model.ContentFeatures
import com.twitter.ml.api.Feature
import com.twitter.ml.api.FeatureContext
import com.twitter.ml.api.RichDataRecord
import com.twitter.ml.api.util.DataRecordConverters.RichDataRecordWrapper
import com.twitter.timelines.prediction.common.adapters.TimelinesMutatingAdapterBase
import com.twitter.timelines.prediction.features.common.InReplyToTweetTimelinesSharedFeatures
object InReplyToContentFeatureAdapter
extends TimelinesMutatingAdapterBase[Option[ContentFeatures]] {
override val getFeatureContext: FeatureContext = new FeatureContext(
// Media Features
InReplyToTweetTimelinesSharedFeatures.ASPECT_RATIO_DEN,
InReplyToTweetTimelinesSharedFeatures.ASPECT_RATIO_NUM,
InReplyToTweetTimelinesSharedFeatures.HEIGHT_1,
InReplyToTweetTimelinesSharedFeatures.HEIGHT_2,
InReplyToTweetTimelinesSharedFeatures.VIDEO_DURATION,
// TextFeatures
InReplyToTweetTimelinesSharedFeatures.NUM_CAPS,
InReplyToTweetTimelinesSharedFeatures.TWEET_LENGTH,
InReplyToTweetTimelinesSharedFeatures.HAS_QUESTION,
)
override val commonFeatures: Set[Feature[_]] = Set.empty
override def setFeatures(
contentFeatures: Option[ContentFeatures],
richDataRecord: RichDataRecord
): Unit = {
if (contentFeatures.nonEmpty) {
val features = contentFeatures.get
richDataRecord.setFeatureValueFromOption(
InReplyToTweetTimelinesSharedFeatures.ASPECT_RATIO_DEN,
features.aspectRatioNum.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
InReplyToTweetTimelinesSharedFeatures.ASPECT_RATIO_NUM,
features.aspectRatioNum.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
InReplyToTweetTimelinesSharedFeatures.HEIGHT_1,
features.heights.flatMap(_.lift(0)).map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
InReplyToTweetTimelinesSharedFeatures.HEIGHT_2,
features.heights.flatMap(_.lift(1)).map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
InReplyToTweetTimelinesSharedFeatures.VIDEO_DURATION,
features.videoDurationMs.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
InReplyToTweetTimelinesSharedFeatures.NUM_CAPS,
Some(features.numCaps.toDouble)
)
richDataRecord.setFeatureValueFromOption(
InReplyToTweetTimelinesSharedFeatures.TWEET_LENGTH,
Some(features.length.toDouble)
)
richDataRecord.setFeatureValueFromOption(
InReplyToTweetTimelinesSharedFeatures.HAS_QUESTION,
Some(features.hasQuestion)
)
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/earlybird/BUILD.bazel | scala_library(
sources = ["*.scala"],
compiler_option_sets = ["fatal_warnings"],
strict_deps = True,
tags = ["bazel-compatible"],
dependencies = [
"src/java/com/twitter/ml/api:api-base",
"src/scala/com/twitter/ml/api:api-base",
"src/scala/com/twitter/ml/api/util",
"src/scala/com/twitter/timelines/prediction/common/adapters:base",
"src/scala/com/twitter/timelines/prediction/features/common",
"src/scala/com/twitter/timelines/prediction/features/recap",
"src/scala/com/twitter/timelines/util",
"src/thrift/com/twitter/ml/api:data-java",
"src/thrift/com/twitter/ml/api:data-scala",
"src/thrift/com/twitter/search/common:features-scala",
"timelines/src/main/scala/com/twitter/timelines/util",
],
)
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/earlybird/EarlybirdAdapter.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.adapters.earlybird
import com.twitter.ml.api.Feature
import com.twitter.ml.api.FeatureContext
import com.twitter.ml.api.RichDataRecord
import com.twitter.ml.api.util.DataRecordConverters._
import com.twitter.timelines.prediction.common.adapters.TimelinesMutatingAdapterBase
import com.twitter.search.common.features.{thriftscala => sc}
import com.twitter.timelines.prediction.features.common.TimelinesSharedFeatures
import com.twitter.timelines.prediction.features.recap.RecapFeatures
import com.twitter.timelines.util.UrlExtractorUtil
import java.lang.{Boolean => JBoolean}
import java.lang.{Double => JDouble}
import java.util.{Map => JMap}
import scala.collection.JavaConverters._
object EarlybirdAdapter extends TimelinesMutatingAdapterBase[Option[sc.ThriftTweetFeatures]] {
override val getFeatureContext: FeatureContext = new FeatureContext(
RecapFeatures.BIDIRECTIONAL_FAV_COUNT,
RecapFeatures.BIDIRECTIONAL_REPLY_COUNT,
RecapFeatures.BIDIRECTIONAL_RETWEET_COUNT,
RecapFeatures.BLENDER_SCORE,
RecapFeatures.CONTAINS_MEDIA,
RecapFeatures.CONVERSATIONAL_COUNT,
RecapFeatures.EMBEDS_IMPRESSION_COUNT,
RecapFeatures.EMBEDS_URL_COUNT,
RecapFeatures.FAV_COUNT,
RecapFeatures.FAV_COUNT_V2,
RecapFeatures.FROM_INACTIVE_USER,
RecapFeatures.FROM_MUTUAL_FOLLOW,
RecapFeatures.FROM_VERIFIED_ACCOUNT,
RecapFeatures.HAS_CARD,
RecapFeatures.HAS_CONSUMER_VIDEO,
RecapFeatures.HAS_HASHTAG,
RecapFeatures.HAS_IMAGE,
RecapFeatures.HAS_LINK,
RecapFeatures.HAS_MENTION,
RecapFeatures.HAS_MULTIPLE_HASHTAGS_OR_TRENDS,
RecapFeatures.HAS_MULTIPLE_MEDIA,
RecapFeatures.HAS_NATIVE_IMAGE,
RecapFeatures.HAS_NATIVE_VIDEO,
RecapFeatures.HAS_NEWS,
RecapFeatures.HAS_PERISCOPE,
RecapFeatures.HAS_PRO_VIDEO,
RecapFeatures.HAS_TREND,
RecapFeatures.HAS_VIDEO,
RecapFeatures.HAS_VINE,
RecapFeatures.HAS_VISIBLE_LINK,
RecapFeatures.IS_AUTHOR_BOT,
RecapFeatures.IS_AUTHOR_NEW,
RecapFeatures.IS_AUTHOR_NSFW,
RecapFeatures.IS_AUTHOR_PROFILE_EGG,
RecapFeatures.IS_AUTHOR_SPAM,
RecapFeatures.IS_BUSINESS_SCORE,
RecapFeatures.IS_OFFENSIVE,
RecapFeatures.IS_REPLY,
RecapFeatures.IS_RETWEET,
RecapFeatures.IS_RETWEETER_BOT,
RecapFeatures.IS_RETWEETER_NEW,
RecapFeatures.IS_RETWEETER_NSFW,
RecapFeatures.IS_RETWEETER_PROFILE_EGG,
RecapFeatures.IS_RETWEETER_SPAM,
RecapFeatures.IS_RETWEET_OF_REPLY,
RecapFeatures.IS_SENSITIVE,
RecapFeatures.LANGUAGE,
RecapFeatures.LINK_COUNT,
RecapFeatures.LINK_LANGUAGE,
RecapFeatures.MATCH_SEARCHER_LANGS,
RecapFeatures.MATCH_SEARCHER_MAIN_LANG,
RecapFeatures.MATCH_UI_LANG,
RecapFeatures.MENTIONED_SCREEN_NAMES,
RecapFeatures.MENTION_SEARCHER,
RecapFeatures.NUM_HASHTAGS,
RecapFeatures.NUM_MENTIONS,
RecapFeatures.PREV_USER_TWEET_ENGAGEMENT,
RecapFeatures.PROBABLY_FROM_FOLLOWED_AUTHOR,
RecapFeatures.REPLY_COUNT,
RecapFeatures.REPLY_COUNT_V2,
RecapFeatures.REPLY_OTHER,
RecapFeatures.REPLY_SEARCHER,
RecapFeatures.RETWEET_COUNT,
RecapFeatures.RETWEET_COUNT_V2,
RecapFeatures.RETWEET_DIRECTED_AT_USER_IN_FIRST_DEGREE,
RecapFeatures.RETWEET_OF_MUTUAL_FOLLOW,
RecapFeatures.RETWEET_OTHER,
RecapFeatures.RETWEET_SEARCHER,
RecapFeatures.SIGNATURE,
RecapFeatures.SOURCE_AUTHOR_REP,
RecapFeatures.TEXT_SCORE,
RecapFeatures.TWEET_COUNT_FROM_USER_IN_SNAPSHOT,
RecapFeatures.UNIDIRECTIONAL_FAV_COUNT,
RecapFeatures.UNIDIRECTIONAL_REPLY_COUNT,
RecapFeatures.UNIDIRECTIONAL_RETWEET_COUNT,
RecapFeatures.URL_DOMAINS,
RecapFeatures.USER_REP,
RecapFeatures.VIDEO_VIEW_COUNT,
// shared features
TimelinesSharedFeatures.WEIGHTED_FAV_COUNT,
TimelinesSharedFeatures.WEIGHTED_RETWEET_COUNT,
TimelinesSharedFeatures.WEIGHTED_REPLY_COUNT,
TimelinesSharedFeatures.WEIGHTED_QUOTE_COUNT,
TimelinesSharedFeatures.EMBEDS_IMPRESSION_COUNT_V2,
TimelinesSharedFeatures.EMBEDS_URL_COUNT_V2,
TimelinesSharedFeatures.DECAYED_FAVORITE_COUNT,
TimelinesSharedFeatures.DECAYED_RETWEET_COUNT,
TimelinesSharedFeatures.DECAYED_REPLY_COUNT,
TimelinesSharedFeatures.DECAYED_QUOTE_COUNT,
TimelinesSharedFeatures.FAKE_FAVORITE_COUNT,
TimelinesSharedFeatures.FAKE_RETWEET_COUNT,
TimelinesSharedFeatures.FAKE_REPLY_COUNT,
TimelinesSharedFeatures.FAKE_QUOTE_COUNT,
TimelinesSharedFeatures.QUOTE_COUNT,
TimelinesSharedFeatures.EARLYBIRD_SCORE,
// Safety features
TimelinesSharedFeatures.LABEL_ABUSIVE_FLAG,
TimelinesSharedFeatures.LABEL_ABUSIVE_HI_RCL_FLAG,
TimelinesSharedFeatures.LABEL_DUP_CONTENT_FLAG,
TimelinesSharedFeatures.LABEL_NSFW_HI_PRC_FLAG,
TimelinesSharedFeatures.LABEL_NSFW_HI_RCL_FLAG,
TimelinesSharedFeatures.LABEL_SPAM_FLAG,
TimelinesSharedFeatures.LABEL_SPAM_HI_RCL_FLAG,
// periscope features
TimelinesSharedFeatures.PERISCOPE_EXISTS,
TimelinesSharedFeatures.PERISCOPE_IS_LIVE,
TimelinesSharedFeatures.PERISCOPE_HAS_BEEN_FEATURED,
TimelinesSharedFeatures.PERISCOPE_IS_CURRENTLY_FEATURED,
TimelinesSharedFeatures.PERISCOPE_IS_FROM_QUALITY_SOURCE,
// VISIBLE_TOKEN_RATIO
TimelinesSharedFeatures.VISIBLE_TOKEN_RATIO,
TimelinesSharedFeatures.HAS_QUOTE,
TimelinesSharedFeatures.IS_COMPOSER_SOURCE_CAMERA,
// health features
TimelinesSharedFeatures.PREPORTED_TWEET_SCORE,
// media
TimelinesSharedFeatures.CLASSIFICATION_LABELS
)
override val commonFeatures: Set[Feature[_]] = Set.empty
override def setFeatures(
ebFeatures: Option[sc.ThriftTweetFeatures],
richDataRecord: RichDataRecord
): Unit = {
if (ebFeatures.nonEmpty) {
val features = ebFeatures.get
richDataRecord.setFeatureValue[JDouble](
RecapFeatures.PREV_USER_TWEET_ENGAGEMENT,
features.prevUserTweetEngagement.toDouble
)
richDataRecord
.setFeatureValue[JBoolean](RecapFeatures.IS_SENSITIVE, features.isSensitiveContent)
richDataRecord
.setFeatureValue[JBoolean](RecapFeatures.HAS_MULTIPLE_MEDIA, features.hasMultipleMedia)
richDataRecord
.setFeatureValue[JBoolean](RecapFeatures.IS_AUTHOR_PROFILE_EGG, features.isAuthorProfileEgg)
richDataRecord.setFeatureValue[JBoolean](RecapFeatures.IS_AUTHOR_NEW, features.isAuthorNew)
richDataRecord
.setFeatureValue[JDouble](RecapFeatures.NUM_MENTIONS, features.numMentions.toDouble)
richDataRecord.setFeatureValue[JBoolean](RecapFeatures.HAS_MENTION, features.numMentions > 0)
richDataRecord
.setFeatureValue[JDouble](RecapFeatures.NUM_HASHTAGS, features.numHashtags.toDouble)
richDataRecord.setFeatureValue[JBoolean](RecapFeatures.HAS_HASHTAG, features.numHashtags > 0)
richDataRecord
.setFeatureValue[JDouble](RecapFeatures.LINK_LANGUAGE, features.linkLanguage.toDouble)
richDataRecord.setFeatureValue[JBoolean](RecapFeatures.IS_AUTHOR_NSFW, features.isAuthorNSFW)
richDataRecord.setFeatureValue[JBoolean](RecapFeatures.IS_AUTHOR_SPAM, features.isAuthorSpam)
richDataRecord.setFeatureValue[JBoolean](RecapFeatures.IS_AUTHOR_BOT, features.isAuthorBot)
richDataRecord.setFeatureValueFromOption(
RecapFeatures.LANGUAGE,
features.language.map(_.getValue.toLong))
richDataRecord.setFeatureValueFromOption(
RecapFeatures.SIGNATURE,
features.signature.map(_.toLong))
richDataRecord
.setFeatureValue[JBoolean](RecapFeatures.FROM_INACTIVE_USER, features.fromInActiveUser)
richDataRecord
.setFeatureValue[JBoolean](
RecapFeatures.PROBABLY_FROM_FOLLOWED_AUTHOR,
features.probablyFromFollowedAuthor)
richDataRecord
.setFeatureValue[JBoolean](RecapFeatures.FROM_MUTUAL_FOLLOW, features.fromMutualFollow)
richDataRecord.setFeatureValue[JBoolean](
RecapFeatures.FROM_VERIFIED_ACCOUNT,
features.fromVerifiedAccount)
richDataRecord.setFeatureValue[JDouble](RecapFeatures.USER_REP, features.userRep)
richDataRecord
.setFeatureValue[JDouble](RecapFeatures.IS_BUSINESS_SCORE, features.isBusinessScore)
richDataRecord
.setFeatureValue[JBoolean](RecapFeatures.HAS_CONSUMER_VIDEO, features.hasConsumerVideo)
richDataRecord.setFeatureValue[JBoolean](RecapFeatures.HAS_PRO_VIDEO, features.hasProVideo)
richDataRecord.setFeatureValue[JBoolean](RecapFeatures.HAS_VINE, features.hasVine)
richDataRecord.setFeatureValue[JBoolean](RecapFeatures.HAS_PERISCOPE, features.hasPeriscope)
richDataRecord
.setFeatureValue[JBoolean](RecapFeatures.HAS_NATIVE_VIDEO, features.hasNativeVideo)
richDataRecord
.setFeatureValue[JBoolean](RecapFeatures.HAS_NATIVE_IMAGE, features.hasNativeImage)
richDataRecord.setFeatureValue[JBoolean](RecapFeatures.HAS_CARD, features.hasCard)
richDataRecord.setFeatureValue[JBoolean](RecapFeatures.HAS_IMAGE, features.hasImage)
richDataRecord.setFeatureValue[JBoolean](RecapFeatures.HAS_NEWS, features.hasNews)
richDataRecord.setFeatureValue[JBoolean](RecapFeatures.HAS_VIDEO, features.hasVideo)
richDataRecord.setFeatureValue[JBoolean](RecapFeatures.CONTAINS_MEDIA, features.containsMedia)
richDataRecord
.setFeatureValue[JBoolean](RecapFeatures.RETWEET_SEARCHER, features.retweetSearcher)
richDataRecord.setFeatureValue[JBoolean](RecapFeatures.REPLY_SEARCHER, features.replySearcher)
richDataRecord
.setFeatureValue[JBoolean](RecapFeatures.MENTION_SEARCHER, features.mentionSearcher)
richDataRecord.setFeatureValue[JBoolean](RecapFeatures.REPLY_OTHER, features.replyOther)
richDataRecord.setFeatureValue[JBoolean](RecapFeatures.RETWEET_OTHER, features.retweetOther)
richDataRecord.setFeatureValue[JBoolean](RecapFeatures.IS_REPLY, features.isReply)
richDataRecord.setFeatureValue[JBoolean](RecapFeatures.IS_RETWEET, features.isRetweet)
richDataRecord.setFeatureValue[JBoolean](RecapFeatures.IS_OFFENSIVE, features.isOffensive)
richDataRecord.setFeatureValue[JBoolean](RecapFeatures.MATCH_UI_LANG, features.matchesUILang)
richDataRecord
.setFeatureValue[JBoolean](
RecapFeatures.MATCH_SEARCHER_MAIN_LANG,
features.matchesSearcherMainLang)
richDataRecord.setFeatureValue[JBoolean](
RecapFeatures.MATCH_SEARCHER_LANGS,
features.matchesSearcherLangs)
richDataRecord
.setFeatureValue[JDouble](
RecapFeatures.BIDIRECTIONAL_FAV_COUNT,
features.bidirectionalFavCount)
richDataRecord
.setFeatureValue[JDouble](
RecapFeatures.UNIDIRECTIONAL_FAV_COUNT,
features.unidirectionalFavCount)
richDataRecord
.setFeatureValue[JDouble](
RecapFeatures.BIDIRECTIONAL_REPLY_COUNT,
features.bidirectionalReplyCount)
richDataRecord
.setFeatureValue[JDouble](
RecapFeatures.UNIDIRECTIONAL_REPLY_COUNT,
features.unidirectionalReplyCount)
richDataRecord
.setFeatureValue[JDouble](
RecapFeatures.BIDIRECTIONAL_RETWEET_COUNT,
features.bidirectionalRetweetCount)
richDataRecord
.setFeatureValue[JDouble](
RecapFeatures.UNIDIRECTIONAL_RETWEET_COUNT,
features.unidirectionalRetweetCount)
richDataRecord
.setFeatureValue[JDouble](RecapFeatures.CONVERSATIONAL_COUNT, features.conversationCount)
richDataRecord.setFeatureValue[JDouble](
RecapFeatures.TWEET_COUNT_FROM_USER_IN_SNAPSHOT,
features.tweetCountFromUserInSnapshot
)
richDataRecord
.setFeatureValue[JBoolean](
RecapFeatures.IS_RETWEETER_PROFILE_EGG,
features.isRetweeterProfileEgg)
richDataRecord
.setFeatureValue[JBoolean](RecapFeatures.IS_RETWEETER_NEW, features.isRetweeterNew)
richDataRecord
.setFeatureValue[JBoolean](RecapFeatures.IS_RETWEETER_BOT, features.isRetweeterBot)
richDataRecord
.setFeatureValue[JBoolean](RecapFeatures.IS_RETWEETER_NSFW, features.isRetweeterNSFW)
richDataRecord
.setFeatureValue[JBoolean](RecapFeatures.IS_RETWEETER_SPAM, features.isRetweeterSpam)
richDataRecord
.setFeatureValue[JBoolean](
RecapFeatures.RETWEET_OF_MUTUAL_FOLLOW,
features.retweetOfMutualFollow)
richDataRecord
.setFeatureValue[JDouble](RecapFeatures.SOURCE_AUTHOR_REP, features.sourceAuthorRep)
richDataRecord
.setFeatureValue[JBoolean](RecapFeatures.IS_RETWEET_OF_REPLY, features.isRetweetOfReply)
richDataRecord.setFeatureValueFromOption(
RecapFeatures.RETWEET_DIRECTED_AT_USER_IN_FIRST_DEGREE,
features.retweetDirectedAtUserInFirstDegree
)
richDataRecord
.setFeatureValue[JDouble](
RecapFeatures.EMBEDS_IMPRESSION_COUNT,
features.embedsImpressionCount.toDouble)
richDataRecord
.setFeatureValue[JDouble](RecapFeatures.EMBEDS_URL_COUNT, features.embedsUrlCount.toDouble)
richDataRecord
.setFeatureValue[JDouble](RecapFeatures.VIDEO_VIEW_COUNT, features.videoViewCount.toDouble)
richDataRecord
.setFeatureValue[JDouble](RecapFeatures.REPLY_COUNT, features.replyCount.toDouble)
richDataRecord
.setFeatureValue[JDouble](RecapFeatures.RETWEET_COUNT, features.retweetCount.toDouble)
richDataRecord.setFeatureValue[JDouble](RecapFeatures.FAV_COUNT, features.favCount.toDouble)
richDataRecord.setFeatureValue[JDouble](RecapFeatures.BLENDER_SCORE, features.blenderScore)
richDataRecord.setFeatureValue[JDouble](RecapFeatures.TEXT_SCORE, features.textScore)
richDataRecord
.setFeatureValue[JBoolean](RecapFeatures.HAS_VISIBLE_LINK, features.hasVisibleLink)
richDataRecord.setFeatureValue[JBoolean](RecapFeatures.HAS_LINK, features.hasLink)
richDataRecord.setFeatureValue[JBoolean](RecapFeatures.HAS_TREND, features.hasTrend)
richDataRecord.setFeatureValue[JBoolean](
RecapFeatures.HAS_MULTIPLE_HASHTAGS_OR_TRENDS,
features.hasMultipleHashtagsOrTrends
)
richDataRecord.setFeatureValueFromOption(
RecapFeatures.FAV_COUNT_V2,
features.favCountV2.map(_.toDouble))
richDataRecord.setFeatureValueFromOption(
RecapFeatures.RETWEET_COUNT_V2,
features.retweetCountV2.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
RecapFeatures.REPLY_COUNT_V2,
features.replyCountV2.map(_.toDouble))
richDataRecord.setFeatureValueFromOption(
RecapFeatures.MENTIONED_SCREEN_NAMES,
features.mentionsList.map(_.toSet.asJava)
)
val urls = features.urlsList.getOrElse(Seq.empty)
richDataRecord.setFeatureValue(
RecapFeatures.URL_DOMAINS,
urls.toSet.flatMap(UrlExtractorUtil.extractDomain).asJava)
richDataRecord.setFeatureValue[JDouble](RecapFeatures.LINK_COUNT, urls.size.toDouble)
// shared features
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.WEIGHTED_FAV_COUNT,
features.weightedFavoriteCount.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.WEIGHTED_RETWEET_COUNT,
features.weightedRetweetCount.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.WEIGHTED_REPLY_COUNT,
features.weightedReplyCount.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.WEIGHTED_QUOTE_COUNT,
features.weightedQuoteCount.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.EMBEDS_IMPRESSION_COUNT_V2,
features.embedsImpressionCountV2.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.EMBEDS_URL_COUNT_V2,
features.embedsUrlCountV2.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.DECAYED_FAVORITE_COUNT,
features.decayedFavoriteCount.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.DECAYED_RETWEET_COUNT,
features.decayedRetweetCount.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.DECAYED_REPLY_COUNT,
features.decayedReplyCount.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.DECAYED_QUOTE_COUNT,
features.decayedQuoteCount.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.FAKE_FAVORITE_COUNT,
features.fakeFavoriteCount.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.FAKE_RETWEET_COUNT,
features.fakeRetweetCount.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.FAKE_REPLY_COUNT,
features.fakeReplyCount.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.FAKE_QUOTE_COUNT,
features.fakeQuoteCount.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.QUOTE_COUNT,
features.quoteCount.map(_.toDouble)
)
richDataRecord.setFeatureValue[JDouble](
TimelinesSharedFeatures.EARLYBIRD_SCORE,
features.earlybirdScore
)
// safety features
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.LABEL_ABUSIVE_FLAG,
features.labelAbusiveFlag
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.LABEL_ABUSIVE_HI_RCL_FLAG,
features.labelAbusiveHiRclFlag
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.LABEL_DUP_CONTENT_FLAG,
features.labelDupContentFlag
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.LABEL_NSFW_HI_PRC_FLAG,
features.labelNsfwHiPrcFlag
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.LABEL_NSFW_HI_RCL_FLAG,
features.labelNsfwHiRclFlag
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.LABEL_SPAM_FLAG,
features.labelSpamFlag
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.LABEL_SPAM_HI_RCL_FLAG,
features.labelSpamHiRclFlag
)
// periscope features
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.PERISCOPE_EXISTS,
features.periscopeExists
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.PERISCOPE_IS_LIVE,
features.periscopeIsLive
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.PERISCOPE_HAS_BEEN_FEATURED,
features.periscopeHasBeenFeatured
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.PERISCOPE_IS_CURRENTLY_FEATURED,
features.periscopeIsCurrentlyFeatured
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.PERISCOPE_IS_FROM_QUALITY_SOURCE,
features.periscopeIsFromQualitySource
)
// misc features
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.VISIBLE_TOKEN_RATIO,
features.visibleTokenRatio.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.HAS_QUOTE,
features.hasQuote
)
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.IS_COMPOSER_SOURCE_CAMERA,
features.isComposerSourceCamera
)
// health scores
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.PREPORTED_TWEET_SCORE,
features.pReportedTweetScore
)
// media
richDataRecord.setFeatureValueFromOption(
TimelinesSharedFeatures.CLASSIFICATION_LABELS,
features.mediaClassificationInfo.map(_.toMap.asJava.asInstanceOf[JMap[String, JDouble]])
)
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/earlybird/InReplyToEarlybirdAdapter.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.adapters.earlybird
import com.twitter.ml.api.Feature
import com.twitter.ml.api.FeatureContext
import com.twitter.ml.api.RichDataRecord
import com.twitter.ml.api.util.DataRecordConverters.RichDataRecordWrapper
import com.twitter.search.common.features.{thriftscala => sc}
import com.twitter.timelines.prediction.common.adapters.TimelinesMutatingAdapterBase
import com.twitter.timelines.prediction.features.common.InReplyToTweetTimelinesSharedFeatures
import com.twitter.timelines.prediction.features.recap.InReplyToRecapFeatures
import java.lang.{Boolean => JBoolean}
import java.lang.{Double => JDouble}
object InReplyToEarlybirdAdapter
extends TimelinesMutatingAdapterBase[Option[sc.ThriftTweetFeatures]] {
override val getFeatureContext: FeatureContext = new FeatureContext(
// TextFeatures
InReplyToTweetTimelinesSharedFeatures.WEIGHTED_FAV_COUNT,
InReplyToTweetTimelinesSharedFeatures.WEIGHTED_RETWEET_COUNT,
InReplyToTweetTimelinesSharedFeatures.WEIGHTED_REPLY_COUNT,
InReplyToTweetTimelinesSharedFeatures.WEIGHTED_QUOTE_COUNT,
InReplyToTweetTimelinesSharedFeatures.DECAYED_FAVORITE_COUNT,
InReplyToTweetTimelinesSharedFeatures.DECAYED_RETWEET_COUNT,
InReplyToTweetTimelinesSharedFeatures.DECAYED_REPLY_COUNT,
InReplyToTweetTimelinesSharedFeatures.DECAYED_QUOTE_COUNT,
InReplyToTweetTimelinesSharedFeatures.QUOTE_COUNT,
InReplyToTweetTimelinesSharedFeatures.HAS_QUOTE,
InReplyToTweetTimelinesSharedFeatures.EARLYBIRD_SCORE,
InReplyToRecapFeatures.PREV_USER_TWEET_ENGAGEMENT,
InReplyToRecapFeatures.IS_SENSITIVE,
InReplyToRecapFeatures.IS_AUTHOR_NEW,
InReplyToRecapFeatures.NUM_MENTIONS,
InReplyToRecapFeatures.HAS_MENTION,
InReplyToRecapFeatures.HAS_HASHTAG,
InReplyToRecapFeatures.IS_AUTHOR_NSFW,
InReplyToRecapFeatures.IS_AUTHOR_SPAM,
InReplyToRecapFeatures.IS_AUTHOR_BOT,
InReplyToRecapFeatures.FROM_MUTUAL_FOLLOW,
InReplyToRecapFeatures.USER_REP,
InReplyToRecapFeatures.FROM_VERIFIED_ACCOUNT,
InReplyToRecapFeatures.HAS_IMAGE,
InReplyToRecapFeatures.HAS_NEWS,
InReplyToRecapFeatures.HAS_VIDEO,
InReplyToRecapFeatures.HAS_VISIBLE_LINK,
InReplyToRecapFeatures.IS_OFFENSIVE,
InReplyToRecapFeatures.IS_REPLY,
InReplyToRecapFeatures.BIDIRECTIONAL_REPLY_COUNT,
InReplyToRecapFeatures.UNIDIRECTIONAL_REPLY_COUNT,
InReplyToRecapFeatures.BIDIRECTIONAL_RETWEET_COUNT,
InReplyToRecapFeatures.UNIDIRECTIONAL_RETWEET_COUNT,
InReplyToRecapFeatures.BIDIRECTIONAL_FAV_COUNT,
InReplyToRecapFeatures.UNIDIRECTIONAL_FAV_COUNT,
InReplyToRecapFeatures.CONVERSATIONAL_COUNT,
InReplyToRecapFeatures.REPLY_COUNT,
InReplyToRecapFeatures.RETWEET_COUNT,
InReplyToRecapFeatures.FAV_COUNT,
InReplyToRecapFeatures.TEXT_SCORE,
InReplyToRecapFeatures.FAV_COUNT_V2,
InReplyToRecapFeatures.RETWEET_COUNT_V2,
InReplyToRecapFeatures.REPLY_COUNT_V2)
override val commonFeatures: Set[Feature[_]] = Set.empty
override def setFeatures(
ebFeatures: Option[sc.ThriftTweetFeatures],
richDataRecord: RichDataRecord
): Unit = {
if (ebFeatures.nonEmpty) {
val features = ebFeatures.get
richDataRecord.setFeatureValueFromOption(
InReplyToTweetTimelinesSharedFeatures.WEIGHTED_FAV_COUNT,
features.weightedFavoriteCount.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
InReplyToTweetTimelinesSharedFeatures.WEIGHTED_RETWEET_COUNT,
features.weightedRetweetCount.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
InReplyToTweetTimelinesSharedFeatures.WEIGHTED_REPLY_COUNT,
features.weightedReplyCount.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
InReplyToTweetTimelinesSharedFeatures.WEIGHTED_QUOTE_COUNT,
features.weightedQuoteCount.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
InReplyToTweetTimelinesSharedFeatures.DECAYED_FAVORITE_COUNT,
features.decayedFavoriteCount.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
InReplyToTweetTimelinesSharedFeatures.DECAYED_RETWEET_COUNT,
features.decayedRetweetCount.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
InReplyToTweetTimelinesSharedFeatures.DECAYED_REPLY_COUNT,
features.decayedReplyCount.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
InReplyToTweetTimelinesSharedFeatures.DECAYED_QUOTE_COUNT,
features.decayedQuoteCount.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
InReplyToTweetTimelinesSharedFeatures.QUOTE_COUNT,
features.quoteCount.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
InReplyToTweetTimelinesSharedFeatures.HAS_QUOTE,
features.hasQuote
)
if (features.earlybirdScore > 0)
richDataRecord.setFeatureValue[JDouble](
InReplyToTweetTimelinesSharedFeatures.EARLYBIRD_SCORE,
features.earlybirdScore
)
richDataRecord.setFeatureValue[JDouble](
InReplyToRecapFeatures.PREV_USER_TWEET_ENGAGEMENT,
features.prevUserTweetEngagement.toDouble
)
richDataRecord
.setFeatureValue[JBoolean](InReplyToRecapFeatures.IS_SENSITIVE, features.isSensitiveContent)
richDataRecord
.setFeatureValue[JBoolean](InReplyToRecapFeatures.IS_AUTHOR_NEW, features.isAuthorNew)
richDataRecord.setFeatureValue[JDouble](
InReplyToRecapFeatures.NUM_MENTIONS,
features.numMentions.toDouble)
richDataRecord
.setFeatureValue[JBoolean](InReplyToRecapFeatures.HAS_MENTION, (features.numMentions > 0))
richDataRecord
.setFeatureValue[JBoolean](InReplyToRecapFeatures.HAS_HASHTAG, (features.numHashtags > 0))
richDataRecord
.setFeatureValue[JBoolean](InReplyToRecapFeatures.IS_AUTHOR_NSFW, features.isAuthorNSFW)
richDataRecord
.setFeatureValue[JBoolean](InReplyToRecapFeatures.IS_AUTHOR_SPAM, features.isAuthorSpam)
richDataRecord
.setFeatureValue[JBoolean](InReplyToRecapFeatures.IS_AUTHOR_BOT, features.isAuthorBot)
richDataRecord.setFeatureValue[JBoolean](
InReplyToRecapFeatures.FROM_MUTUAL_FOLLOW,
features.fromMutualFollow)
richDataRecord.setFeatureValue[JDouble](InReplyToRecapFeatures.USER_REP, features.userRep)
richDataRecord.setFeatureValue[JBoolean](
InReplyToRecapFeatures.FROM_VERIFIED_ACCOUNT,
features.fromVerifiedAccount)
richDataRecord.setFeatureValue[JBoolean](InReplyToRecapFeatures.HAS_IMAGE, features.hasImage)
richDataRecord.setFeatureValue[JBoolean](InReplyToRecapFeatures.HAS_NEWS, features.hasNews)
richDataRecord.setFeatureValue[JBoolean](InReplyToRecapFeatures.HAS_VIDEO, features.hasVideo)
richDataRecord
.setFeatureValue[JBoolean](InReplyToRecapFeatures.HAS_VISIBLE_LINK, features.hasVisibleLink)
richDataRecord
.setFeatureValue[JBoolean](InReplyToRecapFeatures.IS_OFFENSIVE, features.isOffensive)
richDataRecord.setFeatureValue[JBoolean](InReplyToRecapFeatures.IS_REPLY, features.isReply)
richDataRecord.setFeatureValue[JDouble](
InReplyToRecapFeatures.BIDIRECTIONAL_REPLY_COUNT,
features.bidirectionalReplyCount)
richDataRecord.setFeatureValue[JDouble](
InReplyToRecapFeatures.UNIDIRECTIONAL_REPLY_COUNT,
features.unidirectionalReplyCount)
richDataRecord.setFeatureValue[JDouble](
InReplyToRecapFeatures.BIDIRECTIONAL_RETWEET_COUNT,
features.bidirectionalRetweetCount)
richDataRecord.setFeatureValue[JDouble](
InReplyToRecapFeatures.UNIDIRECTIONAL_RETWEET_COUNT,
features.unidirectionalRetweetCount)
richDataRecord.setFeatureValue[JDouble](
InReplyToRecapFeatures.BIDIRECTIONAL_FAV_COUNT,
features.bidirectionalFavCount)
richDataRecord.setFeatureValue[JDouble](
InReplyToRecapFeatures.UNIDIRECTIONAL_FAV_COUNT,
features.unidirectionalFavCount)
richDataRecord.setFeatureValue[JDouble](
InReplyToRecapFeatures.CONVERSATIONAL_COUNT,
features.conversationCount)
richDataRecord
.setFeatureValue[JDouble](InReplyToRecapFeatures.REPLY_COUNT, features.replyCount.toDouble)
richDataRecord.setFeatureValue[JDouble](
InReplyToRecapFeatures.RETWEET_COUNT,
features.retweetCount.toDouble)
richDataRecord
.setFeatureValue[JDouble](InReplyToRecapFeatures.FAV_COUNT, features.favCount.toDouble)
richDataRecord.setFeatureValue[JDouble](InReplyToRecapFeatures.TEXT_SCORE, features.textScore)
richDataRecord.setFeatureValueFromOption(
InReplyToRecapFeatures.FAV_COUNT_V2,
features.favCountV2.map(_.toDouble))
richDataRecord.setFeatureValueFromOption(
InReplyToRecapFeatures.RETWEET_COUNT_V2,
features.retweetCountV2.map(_.toDouble)
)
richDataRecord.setFeatureValueFromOption(
InReplyToRecapFeatures.REPLY_COUNT_V2,
features.replyCountV2.map(_.toDouble))
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/inferred_topic/BUILD.bazel | scala_library(
sources = ["*.scala"],
compiler_option_sets = ["fatal_warnings"],
strict_deps = True,
tags = ["bazel-compatible"],
dependencies = [
"src/java/com/twitter/ml/api:api-base",
"src/scala/com/twitter/ml/api/util",
"src/scala/com/twitter/timelines/prediction/common/adapters:base",
"src/scala/com/twitter/timelines/prediction/features/common",
"src/thrift/com/twitter/ml/api:data-java",
],
)
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/inferred_topic/InferredTopicAdapter.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.adapters.inferred_topic
import com.twitter.ml.api.Feature
import com.twitter.ml.api.FeatureContext
import com.twitter.ml.api.RichDataRecord
import com.twitter.timelines.prediction.common.adapters.TimelinesMutatingAdapterBase
import com.twitter.timelines.prediction.features.common.TimelinesSharedFeatures
import scala.collection.JavaConverters._
object InferredTopicAdapter extends TimelinesMutatingAdapterBase[Map[Long, Double]] {
override val getFeatureContext: FeatureContext = new FeatureContext(
TimelinesSharedFeatures.INFERRED_TOPIC_IDS)
override val commonFeatures: Set[Feature[_]] = Set.empty
override def setFeatures(
inferredTopicFeatures: Map[Long, Double],
richDataRecord: RichDataRecord
): Unit = {
richDataRecord.setFeatureValue(
TimelinesSharedFeatures.INFERRED_TOPIC_IDS,
inferredTopicFeatures.keys.map(_.toString).toSet.asJava)
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/non_ml_features/BUILD.bazel | scala_library(
sources = ["*.scala"],
compiler_option_sets = ["fatal_warnings"],
strict_deps = True,
tags = ["bazel-compatible"],
dependencies = [
"src/java/com/twitter/ml/api:api-base",
"src/java/com/twitter/ml/api/constant",
"src/scala/com/twitter/ml/api/util",
"src/scala/com/twitter/timelines/prediction/common/adapters:base",
"src/scala/com/twitter/timelines/prediction/features/common",
"src/thrift/com/twitter/ml/api:data-java",
"src/thrift/com/twitter/timelines/author_features:thrift-java",
],
)
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/non_ml_features/NonMLCandidateFeaturesAdapter.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.adapters.non_ml_features
import com.twitter.ml.api.constant.SharedFeatures
import com.twitter.ml.api.Feature
import com.twitter.ml.api.FeatureContext
import com.twitter.ml.api.RichDataRecord
import com.twitter.timelines.prediction.common.adapters.TimelinesMutatingAdapterBase
import com.twitter.timelines.prediction.features.common.TimelinesSharedFeatures
import java.lang.{Long => JLong}
case class NonMLCandidateFeatures(
tweetId: Long,
sourceTweetId: Option[Long],
originalAuthorId: Option[Long],
)
/**
* define non ml features adapter to create a data record which includes many non ml features
* e.g. predictionRequestId, userId, tweetId to be used as joined key in batch pipeline.
*/
object NonMLCandidateFeaturesAdapter extends TimelinesMutatingAdapterBase[NonMLCandidateFeatures] {
private val featureContext = new FeatureContext(
SharedFeatures.TWEET_ID,
// For Secondary Engagement data generation
TimelinesSharedFeatures.SOURCE_TWEET_ID,
TimelinesSharedFeatures.ORIGINAL_AUTHOR_ID,
)
override def getFeatureContext: FeatureContext = featureContext
override val commonFeatures: Set[Feature[_]] = Set.empty
override def setFeatures(
nonMLCandidateFeatures: NonMLCandidateFeatures,
richDataRecord: RichDataRecord
): Unit = {
richDataRecord.setFeatureValue[JLong](SharedFeatures.TWEET_ID, nonMLCandidateFeatures.tweetId)
nonMLCandidateFeatures.sourceTweetId.foreach(
richDataRecord.setFeatureValue[JLong](TimelinesSharedFeatures.SOURCE_TWEET_ID, _))
nonMLCandidateFeatures.originalAuthorId.foreach(
richDataRecord.setFeatureValue[JLong](TimelinesSharedFeatures.ORIGINAL_AUTHOR_ID, _))
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/non_ml_features/NonMLCommonFeaturesAdapter.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.adapters.non_ml_features
import com.twitter.ml.api.constant.SharedFeatures
import com.twitter.ml.api.Feature
import com.twitter.ml.api.FeatureContext
import com.twitter.ml.api.RichDataRecord
import com.twitter.timelines.prediction.common.adapters.TimelinesMutatingAdapterBase
import com.twitter.timelines.prediction.features.common.TimelinesSharedFeatures
import java.lang.{Long => JLong}
case class NonMLCommonFeatures(
userId: Long,
predictionRequestId: Option[Long],
servedTimestamp: Long,
)
/**
* define non ml features adapter to create a data record which includes many non ml features
* e.g. predictionRequestId, userId, tweetId to be used as joined key in batch pipeline.
*/
object NonMLCommonFeaturesAdapter extends TimelinesMutatingAdapterBase[NonMLCommonFeatures] {
private val featureContext = new FeatureContext(
SharedFeatures.USER_ID,
TimelinesSharedFeatures.PREDICTION_REQUEST_ID,
TimelinesSharedFeatures.SERVED_TIMESTAMP,
)
override def getFeatureContext: FeatureContext = featureContext
override val commonFeatures: Set[Feature[_]] = Set(
SharedFeatures.USER_ID,
TimelinesSharedFeatures.PREDICTION_REQUEST_ID,
TimelinesSharedFeatures.SERVED_TIMESTAMP,
)
override def setFeatures(
nonMLCommonFeatures: NonMLCommonFeatures,
richDataRecord: RichDataRecord
): Unit = {
richDataRecord.setFeatureValue[JLong](SharedFeatures.USER_ID, nonMLCommonFeatures.userId)
nonMLCommonFeatures.predictionRequestId.foreach(
richDataRecord.setFeatureValue[JLong](TimelinesSharedFeatures.PREDICTION_REQUEST_ID, _))
richDataRecord.setFeatureValue[JLong](
TimelinesSharedFeatures.SERVED_TIMESTAMP,
nonMLCommonFeatures.servedTimestamp)
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/offline_aggregates/BUILD.bazel | scala_library(
sources = ["*.scala"],
compiler_option_sets = ["fatal_warnings"],
strict_deps = True,
tags = ["bazel-compatible"],
dependencies = [
"src/java/com/twitter/ml/api:api-base",
"src/scala/com/twitter/timelines/prediction/common/adapters:base",
"src/thrift/com/twitter/ml/api:data-java",
"timelines/data_processing/ml_util/aggregation_framework/conversion:for-timelines",
"timelineservice/common/src/main/scala/com/twitter/timelineservice/model",
],
)
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/offline_aggregates/PassThroughAdapter.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.adapters.offline_aggregates
import com.twitter.ml.api.DataRecord
import com.twitter.ml.api.IRecordOneToOneAdapter
object PassThroughAdapter extends IRecordOneToOneAdapter[Seq[DataRecord]] {
override def adaptToDataRecord(record: Seq[DataRecord]): DataRecord =
record.headOption.getOrElse(new DataRecord)
// This is not necessary and should not be used.
override def getFeatureContext = ???
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/offline_aggregates/SparseAggregatesToDenseAdapter.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.adapters.offline_aggregates
import com.twitter.ml.api.DataRecord
import com.twitter.ml.api.FeatureContext
import com.twitter.ml.api.RichDataRecord
import com.twitter.timelines.data_processing.ml_util.aggregation_framework.conversion.CombineCountsPolicy
import com.twitter.timelines.prediction.common.adapters.TimelinesIRecordAdapter
class SparseAggregatesToDenseAdapter(policy: CombineCountsPolicy)
extends TimelinesIRecordAdapter[Seq[DataRecord]] {
override def setFeatures(input: Seq[DataRecord], mutableDataRecord: RichDataRecord): Unit =
policy.defaultMergeRecord(mutableDataRecord.getRecord, input.toList)
override val getFeatureContext: FeatureContext =
new FeatureContext(policy.outputFeaturesPostMerge.toSeq: _*)
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/twhin_embeddings/BUILD.bazel | scala_library(
sources = ["*.scala"],
compiler_option_sets = ["fatal_warnings"],
strict_deps = True,
tags = ["bazel-compatible"],
dependencies = [
"src/java/com/twitter/ml/api:api-base",
"src/scala/com/twitter/ml/api:api-base",
"src/scala/com/twitter/ml/api/util",
"src/scala/com/twitter/timelines/prediction/common/adapters:base",
"src/thrift/com/twitter/ml/api:data-java",
"src/thrift/com/twitter/ml/api:data-scala",
"src/thrift/com/twitter/ml/api:embedding-java",
"src/thrift/com/twitter/ml/api:embedding-scala",
],
)
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/twhin_embeddings/TwhinEmbeddingsAdapter.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.adapters.twhin_embeddings
import com.twitter.ml.api.DataType
import com.twitter.ml.api.Feature
import com.twitter.ml.api.FeatureContext
import com.twitter.ml.api.RichDataRecord
import com.twitter.ml.api.util.ScalaToJavaDataRecordConversions
import com.twitter.ml.api.{thriftscala => ml}
import com.twitter.timelines.prediction.common.adapters.TimelinesMutatingAdapterBase
sealed trait TwhinEmbeddingsAdapter extends TimelinesMutatingAdapterBase[Option[ml.FloatTensor]] {
def twhinEmbeddingsFeature: Feature.Tensor
override def getFeatureContext: FeatureContext = new FeatureContext(
twhinEmbeddingsFeature
)
override def setFeatures(
embedding: Option[ml.FloatTensor],
richDataRecord: RichDataRecord
): Unit = {
embedding.foreach { floatTensor =>
richDataRecord.setFeatureValue(
twhinEmbeddingsFeature,
ScalaToJavaDataRecordConversions.scalaTensor2Java(
ml.GeneralTensor
.FloatTensor(floatTensor)))
}
}
}
object TwhinEmbeddingsFeatures {
val TwhinAuthorFollowEmbeddingsFeature: Feature.Tensor = new Feature.Tensor(
"original_author.twhin.tw_hi_n.author_follow_as_float_tensor",
DataType.FLOAT
)
val TwhinUserEngagementEmbeddingsFeature: Feature.Tensor = new Feature.Tensor(
"user.twhin.tw_hi_n.user_engagement_as_float_tensor",
DataType.FLOAT
)
val TwhinUserFollowEmbeddingsFeature: Feature.Tensor = new Feature.Tensor(
"user.twhin.tw_hi_n.user_follow_as_float_tensor",
DataType.FLOAT
)
}
object TwhinAuthorFollowEmbeddingsAdapter extends TwhinEmbeddingsAdapter {
override val twhinEmbeddingsFeature: Feature.Tensor =
TwhinEmbeddingsFeatures.TwhinAuthorFollowEmbeddingsFeature
override val commonFeatures: Set[Feature[_]] = Set.empty
}
object TwhinUserEngagementEmbeddingsAdapter extends TwhinEmbeddingsAdapter {
override val twhinEmbeddingsFeature: Feature.Tensor =
TwhinEmbeddingsFeatures.TwhinUserEngagementEmbeddingsFeature
override val commonFeatures: Set[Feature[_]] = Set(twhinEmbeddingsFeature)
}
object TwhinUserFollowEmbeddingsAdapter extends TwhinEmbeddingsAdapter {
override val twhinEmbeddingsFeature: Feature.Tensor =
TwhinEmbeddingsFeatures.TwhinUserFollowEmbeddingsFeature
override val commonFeatures: Set[Feature[_]] = Set(twhinEmbeddingsFeature)
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/offline_aggregates/AggregateFeatureInfo.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.offline_aggregates
import com.twitter.ml.api.FeatureContext
import com.twitter.timelines.data_processing.ml_util.aggregation_framework.AggregateGroup
import com.twitter.timelines.data_processing.ml_util.aggregation_framework.AggregateType.AggregateType
import com.twitter.timelines.data_processing.ml_util.aggregation_framework.TypedAggregateGroup
import scala.jdk.CollectionConverters.asJavaIterableConverter
// A helper class deriving aggregate feature info from the given configuration parameters.
class AggregateFeatureInfo(
val aggregateGroups: Set[AggregateGroup],
val aggregateType: AggregateType) {
private val typedAggregateGroups = aggregateGroups.flatMap(_.buildTypedAggregateGroups()).toList
val featureContext: FeatureContext =
new FeatureContext(
(typedAggregateGroups.flatMap(_.allOutputFeatures) ++
typedAggregateGroups.flatMap(_.allOutputKeys) ++
Seq(TypedAggregateGroup.timestampFeature)).asJava)
val feature: BaseAggregateRootFeature =
AggregateFeatureInfo.pickFeature(aggregateType)
}
object AggregateFeatureInfo {
val features: Set[BaseAggregateRootFeature] =
Set(PartAAggregateRootFeature, PartBAggregateRootFeature)
def pickFeature(aggregateType: AggregateType): BaseAggregateRootFeature = {
val filtered = features.filter(_.aggregateTypes.contains(aggregateType))
require(
filtered.size == 1,
"requested AggregateType must be backed by exactly one physical store.")
filtered.head
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/offline_aggregates/AggregateFeaturesToDecodeWithMetadata.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.offline_aggregates
import com.twitter.finagle.stats.NullStatsReceiver
import com.twitter.timelinemixer.injection.repository.uss.VersionedAggregateFeaturesDecoder
import com.twitter.ml.api.DataRecord
import com.twitter.timelines.aggregate_interactions.thriftjava.UserAggregateInteractions
import com.twitter.timelines.aggregate_interactions.v17.thriftjava.{
UserAggregateInteractions => V17UserAggregateInteractions
}
import com.twitter.timelines.aggregate_interactions.v1.thriftjava.{
UserAggregateInteractions => V1UserAggregateInteractions
}
import com.twitter.timelines.suggests.common.dense_data_record.thriftjava.DenseCompactDataRecord
import com.twitter.timelines.suggests.common.dense_data_record.thriftscala.DenseFeatureMetadata
import java.lang.{Long => JLong}
import java.util.Collections
import java.util.{Map => JMap}
private[offline_aggregates] case class AggregateFeaturesToDecodeWithMetadata(
metadataOpt: Option[DenseFeatureMetadata],
aggregates: UserAggregateInteractions) {
def toDataRecord(dr: DenseCompactDataRecord): DataRecord =
VersionedAggregateFeaturesDecoder.fromJDenseCompact(
metadataOpt,
dr.versionId,
NullStatsReceiver,
s"V${dr.versionId}"
)(dr)
def userAggregatesOpt: Option[DenseCompactDataRecord] = {
aggregates.getSetField match {
case UserAggregateInteractions._Fields.V17 =>
Option(aggregates.getV17.user_aggregates)
case _ =>
None
}
}
def userAuthorAggregates = extract(_.user_author_aggregates)
def userEngagerAggregates = extract(_.user_engager_aggregates)
def userMentionAggregates = extract(_.user_mention_aggregates)
def userOriginalAuthorAggregates = extract(_.user_original_author_aggregates)
def userRequestDowAggregates = extract(_.user_request_dow_aggregates)
def userRequestHourAggregates = extract(_.user_request_hour_aggregates)
def rectweetUserSimclustersTweetAggregates = extract(_.rectweet_user_simclusters_tweet_aggregates)
def userTwitterListAggregates = extract(_.user_list_aggregates)
def userTopicAggregates = extract(_.user_topic_aggregates)
def userInferredTopicAggregates = extract(_.user_inferred_topic_aggregates)
def userMediaUnderstandingAnnotationAggregates = extract(
_.user_media_understanding_annotation_aggregates)
private def extract[T](
v17Fn: V17UserAggregateInteractions => JMap[JLong, DenseCompactDataRecord]
): JMap[JLong, DenseCompactDataRecord] = {
aggregates.getSetField match {
case UserAggregateInteractions._Fields.V17 =>
v17Fn(aggregates.getV17)
case _ =>
Collections.emptyMap()
}
}
}
object AggregateFeaturesToDecodeWithMetadata {
val empty = new AggregateFeaturesToDecodeWithMetadata(
None,
UserAggregateInteractions.v1(new V1UserAggregateInteractions()))
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/offline_aggregates/BUILD.bazel | scala_library(
sources = ["*.scala"],
compiler_option_sets = ["fatal_warnings"],
strict_deps = True,
tags = ["bazel-compatible"],
dependencies = [
"finatra/inject/inject-core/src/main/scala",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/functional_component/feature_hydrator",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/model",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/param",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/adapters/offline_aggregates",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/util",
"product-mixer/component-library/src/main/scala/com/twitter/product_mixer/component_library/model/candidate",
"product-mixer/core/src/main/scala/com/twitter/product_mixer/core/feature/datarecord",
"product-mixer/core/src/main/scala/com/twitter/product_mixer/core/feature/featuremap/datarecord",
"product-mixer/core/src/main/scala/com/twitter/product_mixer/core/functional_component/feature_hydrator",
"product-mixer/core/src/main/scala/com/twitter/product_mixer/core/util",
"servo/repo/src/main/scala",
"src/java/com/twitter/ml/api:api-base",
"src/scala/com/twitter/timelines/prediction/adapters/request_context",
"src/scala/com/twitter/timelines/prediction/common/adapters:base",
"src/scala/com/twitter/timelines/prediction/common/aggregates",
"src/scala/com/twitter/timelines/util",
"src/thrift/com/twitter/ml/api:data-java",
"src/thrift/com/twitter/timelines/suggests/common:data_record_metadata-scala",
"src/thrift/com/twitter/timelines/suggests/common:dense_data_record-scala",
"src/thrift/com/twitter/tweetypie:service-scala",
"src/thrift/com/twitter/tweetypie:tweet-scala",
"src/thrift/com/twitter/user_session_store:thrift-java",
"stitch/stitch-core",
"timelinemixer/server/src/main/scala/com/twitter/timelinemixer/injection/repository/uss:versioned-aggregate-features-decoder",
"timelines/data_processing/jobs/timeline_ranking_user_features:mini",
"timelines/data_processing/ml_util/aggregation_framework:common_types",
"timelines/data_processing/ml_util/aggregation_framework/conversion:for-timelines",
"timelineservice/common/src/main/scala/com/twitter/timelineservice/model",
"user_session_store/src/main/scala/com/twitter/user_session_store",
"util/util-core",
],
)
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/offline_aggregates/BaseAggregateQueryFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.offline_aggregates
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.QueryFeatureHydrator
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.servo.repository.Repository
import com.twitter.stitch.Stitch
import com.twitter.timelines.aggregate_interactions.thriftjava.UserAggregateInteractions
import com.twitter.timelines.data_processing.ml_util.aggregation_framework.AggregateType.AggregateType
import com.twitter.timelines.data_processing.ml_util.aggregation_framework.StoreConfig
import com.twitter.timelines.suggests.common.dense_data_record.thriftscala.DenseFeatureMetadata
import com.twitter.user_session_store.thriftjava.UserSession
import com.twitter.util.Future
abstract class BaseAggregateQueryFeatureHydrator(
featureRepository: Repository[Long, Option[UserSession]],
metadataRepository: Repository[Int, Option[DenseFeatureMetadata]],
feature: Feature[PipelineQuery, Option[AggregateFeaturesToDecodeWithMetadata]])
extends QueryFeatureHydrator[PipelineQuery] {
override def hydrate(query: PipelineQuery): Stitch[FeatureMap] = {
val viewerId = query.getRequiredUserId
Stitch.callFuture(
featureRepository(viewerId)
.flatMap { userSession: Option[UserSession] =>
val featuresWithMetadata: Option[Future[AggregateFeaturesToDecodeWithMetadata]] =
userSession
.flatMap(decodeUserSession(_))
featuresWithMetadata
.map { fu: Future[AggregateFeaturesToDecodeWithMetadata] => fu.map(Some(_)) }
.getOrElse(Future.None)
.map { value =>
FeatureMapBuilder()
.add(feature, value)
.build()
}
}
)
}
private def decodeUserSession(
session: UserSession
): Option[Future[AggregateFeaturesToDecodeWithMetadata]] = {
Option(session.user_aggregate_interactions).flatMap { aggregates =>
aggregates.getSetField match {
case UserAggregateInteractions._Fields.V17 =>
Some(
getAggregateFeaturesWithMetadata(
aggregates.getV17.user_aggregates.versionId,
UserAggregateInteractions.v17(aggregates.getV17))
)
case _ =>
None
}
}
}
private def getAggregateFeaturesWithMetadata(
versionId: Int,
userAggregateInteractions: UserAggregateInteractions,
): Future[AggregateFeaturesToDecodeWithMetadata] = {
metadataRepository(versionId)
.map(AggregateFeaturesToDecodeWithMetadata(_, userAggregateInteractions))
}
}
trait BaseAggregateRootFeature
extends Feature[PipelineQuery, Option[AggregateFeaturesToDecodeWithMetadata]] {
def aggregateStores: Set[StoreConfig[_]]
lazy val aggregateTypes: Set[AggregateType] = aggregateStores.map(_.aggregateType)
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/offline_aggregates/BaseEdgeAggregateFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.offline_aggregates
import com.twitter.ml.api.DataRecord
import com.twitter.ml.api.FeatureContext
import com.twitter.ml.api.IRecordOneToOneAdapter
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BulkCandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.util.OffloadFuturePools
import com.twitter.stitch.Stitch
import com.twitter.timelines.data_processing.ml_util.aggregation_framework.AggregateGroup
import com.twitter.timelines.data_processing.ml_util.aggregation_framework.AggregateType.AggregateType
import com.twitter.timelines.suggests.common.dense_data_record.thriftjava.DenseCompactDataRecord
import java.lang.{Long => JLong}
import java.util.{Map => JMap}
abstract case class BaseEdgeAggregateFeature(
aggregateGroups: Set[AggregateGroup],
aggregateType: AggregateType,
extractMapFn: AggregateFeaturesToDecodeWithMetadata => JMap[JLong, DenseCompactDataRecord],
adapter: IRecordOneToOneAdapter[Seq[DataRecord]],
getSecondaryKeysFn: CandidateWithFeatures[TweetCandidate] => Seq[Long])
extends DataRecordInAFeature[PipelineQuery]
with FeatureWithDefaultOnFailure[PipelineQuery, DataRecord] {
override def defaultValue: DataRecord = new DataRecord
private val rootFeatureInfo = new AggregateFeatureInfo(aggregateGroups, aggregateType)
val featureContext: FeatureContext = rootFeatureInfo.featureContext
val rootFeature: BaseAggregateRootFeature = rootFeatureInfo.feature
}
trait BaseEdgeAggregateFeatureHydrator
extends BulkCandidateFeatureHydrator[PipelineQuery, TweetCandidate] {
def aggregateFeatures: Set[BaseEdgeAggregateFeature]
override def features = aggregateFeatures.asInstanceOf[Set[Feature[_, _]]]
override def apply(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Stitch[Seq[FeatureMap]] = OffloadFuturePools.offload {
val featureMapBuilders: Seq[FeatureMapBuilder] =
for (_ <- candidates) yield FeatureMapBuilder()
aggregateFeatures.foreach { feature =>
val featureValues = hydrateAggregateFeature(query, candidates, feature)
(featureMapBuilders zip featureValues).foreach {
case (featureMapBuilder, featureValue) => featureMapBuilder.add(feature, featureValue)
}
}
featureMapBuilders.map(_.build())
}
private def hydrateAggregateFeature(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]],
feature: BaseEdgeAggregateFeature
): Seq[DataRecord] = {
val rootFeature = feature.rootFeature
val extractMapFn = feature.extractMapFn
val featureContext = feature.featureContext
val secondaryIds: Seq[Seq[Long]] = candidates.map(feature.getSecondaryKeysFn)
val featuresToDecodeWithMetadata = query.features
.flatMap(_.getOrElse(rootFeature, None))
.getOrElse(AggregateFeaturesToDecodeWithMetadata.empty)
// Decode the DenseCompactDataRecords into DataRecords for each required secondary id.
val decoded: Map[Long, DataRecord] = Utils.selectAndTransform(
secondaryIds.flatten.distinct,
featuresToDecodeWithMetadata.toDataRecord,
extractMapFn(featuresToDecodeWithMetadata)
)
// Remove unnecessary features in-place. This is safe because the underlying DataRecords
// are unique and have just been generated in the previous step.
decoded.values.foreach(Utils.filterDataRecord(_, featureContext))
// Put features into the FeatureMapBuilders
secondaryIds.map { ids =>
val dataRecords = ids.flatMap(decoded.get)
feature.adapter.adaptToDataRecord(dataRecords)
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/offline_aggregates/EdgeAggregateFeatures.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.offline_aggregates
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.adapters.offline_aggregates.PassThroughAdapter
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.adapters.offline_aggregates.SparseAggregatesToDenseAdapter
import com.twitter.home_mixer.model.HomeFeatures.AuthorIdFeature
import com.twitter.home_mixer.model.HomeFeatures.MentionScreenNameFeature
import com.twitter.home_mixer.model.HomeFeatures.TopicIdSocialContextFeature
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.TSPInferredTopicFeature
import com.twitter.home_mixer.util.CandidatesUtil
import com.twitter.timelines.data_processing.ml_util.aggregation_framework.AggregateType
import com.twitter.timelines.prediction.common.aggregates.TimelinesAggregationConfig
import com.twitter.timelines.prediction.common.aggregates.TimelinesAggregationConfig.CombineCountPolicies
object EdgeAggregateFeatures {
object UserAuthorAggregateFeature
extends BaseEdgeAggregateFeature(
aggregateGroups = TimelinesAggregationConfig.userAuthorAggregatesV2 ++ Set(
TimelinesAggregationConfig.userAuthorAggregatesV5,
TimelinesAggregationConfig.tweetSourceUserAuthorAggregatesV1,
TimelinesAggregationConfig.twitterWideUserAuthorAggregates
),
aggregateType = AggregateType.UserAuthor,
extractMapFn = _.userAuthorAggregates,
adapter = PassThroughAdapter,
getSecondaryKeysFn = _.features.getOrElse(AuthorIdFeature, None).toSeq
)
object UserOriginalAuthorAggregateFeature
extends BaseEdgeAggregateFeature(
aggregateGroups = Set(TimelinesAggregationConfig.userOriginalAuthorAggregatesV1),
aggregateType = AggregateType.UserOriginalAuthor,
extractMapFn = _.userOriginalAuthorAggregates,
adapter = PassThroughAdapter,
getSecondaryKeysFn = candidate =>
CandidatesUtil.getOriginalAuthorId(candidate.features).toSeq
)
object UserTopicAggregateFeature
extends BaseEdgeAggregateFeature(
aggregateGroups = Set(
TimelinesAggregationConfig.userTopicAggregates,
TimelinesAggregationConfig.userTopicAggregatesV2,
),
aggregateType = AggregateType.UserTopic,
extractMapFn = _.userTopicAggregates,
adapter = PassThroughAdapter,
getSecondaryKeysFn = candidate =>
candidate.features.getOrElse(TopicIdSocialContextFeature, None).toSeq
)
object UserMentionAggregateFeature
extends BaseEdgeAggregateFeature(
aggregateGroups = Set(TimelinesAggregationConfig.userMentionAggregates),
aggregateType = AggregateType.UserMention,
extractMapFn = _.userMentionAggregates,
adapter = new SparseAggregatesToDenseAdapter(CombineCountPolicies.MentionCountsPolicy),
getSecondaryKeysFn = candidate =>
candidate.features.getOrElse(MentionScreenNameFeature, Seq.empty).map(_.hashCode.toLong)
)
object UserInferredTopicAggregateFeature
extends BaseEdgeAggregateFeature(
aggregateGroups = Set(
TimelinesAggregationConfig.userInferredTopicAggregates,
),
aggregateType = AggregateType.UserInferredTopic,
extractMapFn = _.userInferredTopicAggregates,
adapter = new SparseAggregatesToDenseAdapter(
CombineCountPolicies.UserInferredTopicCountsPolicy),
getSecondaryKeysFn = candidate =>
candidate.features.getOrElse(TSPInferredTopicFeature, Map.empty[Long, Double]).keys.toSeq
)
object UserInferredTopicAggregateV2Feature
extends BaseEdgeAggregateFeature(
aggregateGroups = Set(
TimelinesAggregationConfig.userInferredTopicAggregatesV2
),
aggregateType = AggregateType.UserInferredTopic,
extractMapFn = _.userInferredTopicAggregates,
adapter = new SparseAggregatesToDenseAdapter(
CombineCountPolicies.UserInferredTopicV2CountsPolicy),
getSecondaryKeysFn = candidate =>
candidate.features.getOrElse(TSPInferredTopicFeature, Map.empty[Long, Double]).keys.toSeq
)
object UserMediaUnderstandingAnnotationAggregateFeature
extends BaseEdgeAggregateFeature(
aggregateGroups = Set(
TimelinesAggregationConfig.userMediaUnderstandingAnnotationAggregates),
aggregateType = AggregateType.UserMediaUnderstandingAnnotation,
extractMapFn = _.userMediaUnderstandingAnnotationAggregates,
adapter = new SparseAggregatesToDenseAdapter(
CombineCountPolicies.UserMediaUnderstandingAnnotationCountsPolicy),
getSecondaryKeysFn = candidate =>
CandidatesUtil.getMediaUnderstandingAnnotationIds(candidate.features)
)
object UserEngagerAggregateFeature
extends BaseEdgeAggregateFeature(
aggregateGroups = Set(TimelinesAggregationConfig.userEngagerAggregates),
aggregateType = AggregateType.UserEngager,
extractMapFn = _.userEngagerAggregates,
adapter = new SparseAggregatesToDenseAdapter(CombineCountPolicies.EngagerCountsPolicy),
getSecondaryKeysFn = candidate => CandidatesUtil.getEngagerUserIds(candidate.features)
)
object UserEngagerGoodClickAggregateFeature
extends BaseEdgeAggregateFeature(
aggregateGroups = Set(TimelinesAggregationConfig.userEngagerGoodClickAggregates),
aggregateType = AggregateType.UserEngager,
extractMapFn = _.userEngagerAggregates,
adapter = new SparseAggregatesToDenseAdapter(
CombineCountPolicies.EngagerGoodClickCountsPolicy),
getSecondaryKeysFn = candidate => CandidatesUtil.getEngagerUserIds(candidate.features)
)
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/offline_aggregates/PartAAggregateQueryFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.offline_aggregates
import com.twitter.home_mixer.param.HomeMixerInjectionNames.TimelineAggregateMetadataRepository
import com.twitter.home_mixer.param.HomeMixerInjectionNames.TimelineAggregatePartARepository
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.servo.repository.Repository
import com.twitter.timelines.data_processing.jobs.timeline_ranking_user_features.TimelinesPartAStoreRegister
import com.twitter.timelines.data_processing.ml_util.aggregation_framework.StoreConfig
import com.twitter.timelines.suggests.common.dense_data_record.thriftscala.DenseFeatureMetadata
import com.twitter.user_session_store.thriftjava.UserSession
import javax.inject.Inject
import javax.inject.Named
import javax.inject.Singleton
object PartAAggregateRootFeature extends BaseAggregateRootFeature {
override val aggregateStores: Set[StoreConfig[_]] = TimelinesPartAStoreRegister.allStores
}
@Singleton
class PartAAggregateQueryFeatureHydrator @Inject() (
@Named(TimelineAggregatePartARepository)
repository: Repository[Long, Option[UserSession]],
@Named(TimelineAggregateMetadataRepository)
metadataRepository: Repository[Int, Option[DenseFeatureMetadata]])
extends BaseAggregateQueryFeatureHydrator(
repository,
metadataRepository,
PartAAggregateRootFeature
) {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("PartAAggregateQuery")
override val features = Set(PartAAggregateRootFeature)
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/offline_aggregates/PartBAggregateQueryFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.offline_aggregates
import com.twitter.home_mixer.param.HomeMixerInjectionNames.TimelineAggregateMetadataRepository
import com.twitter.home_mixer.param.HomeMixerInjectionNames.TimelineAggregatePartBRepository
import com.twitter.ml.api.DataRecord
import com.twitter.ml.api.DataRecordMerger
import com.twitter.ml.api.FeatureContext
import com.twitter.ml.api.RichDataRecord
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.servo.repository.Repository
import com.twitter.stitch.Stitch
import com.twitter.timelines.data_processing.jobs.timeline_ranking_user_features.TimelinesPartBStoreRegister
import com.twitter.timelines.data_processing.ml_util.aggregation_framework.AggregateType
import com.twitter.timelines.data_processing.ml_util.aggregation_framework.StoreConfig
import com.twitter.timelines.prediction.adapters.request_context.RequestContextAdapter
import com.twitter.timelines.prediction.common.aggregates.TimelinesAggregationConfig
import com.twitter.timelines.suggests.common.dense_data_record.thriftscala.DenseFeatureMetadata
import com.twitter.user_session_store.thriftjava.UserSession
import com.twitter.util.Time
import javax.inject.Inject
import javax.inject.Named
import javax.inject.Singleton
object PartBAggregateRootFeature extends BaseAggregateRootFeature {
override val aggregateStores: Set[StoreConfig[_]] = TimelinesPartBStoreRegister.allStores
}
object UserAggregateFeature
extends DataRecordInAFeature[PipelineQuery]
with FeatureWithDefaultOnFailure[PipelineQuery, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
@Singleton
class PartBAggregateQueryFeatureHydrator @Inject() (
@Named(TimelineAggregatePartBRepository)
repository: Repository[Long, Option[UserSession]],
@Named(TimelineAggregateMetadataRepository)
metadataRepository: Repository[Int, Option[DenseFeatureMetadata]])
extends BaseAggregateQueryFeatureHydrator(
repository,
metadataRepository,
PartBAggregateRootFeature
) {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("PartBAggregateQuery")
override val features: Set[Feature[_, _]] =
Set(PartBAggregateRootFeature, UserAggregateFeature)
private val userAggregateFeatureInfo = new AggregateFeatureInfo(
aggregateGroups = Set(
TimelinesAggregationConfig.userAggregatesV2,
TimelinesAggregationConfig.userAggregatesV5Continuous,
TimelinesAggregationConfig.userAggregatesV6,
TimelinesAggregationConfig.twitterWideUserAggregates,
),
aggregateType = AggregateType.User
)
private val userHourAggregateFeatureInfo = new AggregateFeatureInfo(
aggregateGroups = Set(
TimelinesAggregationConfig.userRequestHourAggregates,
),
aggregateType = AggregateType.UserRequestHour
)
private val userDowAggregateFeatureInfo = new AggregateFeatureInfo(
aggregateGroups = Set(
TimelinesAggregationConfig.userRequestDowAggregates
),
aggregateType = AggregateType.UserRequestDow
)
require(
userAggregateFeatureInfo.feature == PartBAggregateRootFeature,
"UserAggregates feature must be provided by the PartB data source.")
require(
userHourAggregateFeatureInfo.feature == PartBAggregateRootFeature,
"UserRequstHourAggregates feature must be provided by the PartB data source.")
require(
userDowAggregateFeatureInfo.feature == PartBAggregateRootFeature,
"UserRequestDowAggregates feature must be provided by the PartB data source.")
override def hydrate(query: PipelineQuery): Stitch[FeatureMap] = {
// Hydrate TimelineAggregatePartBFeature and UserAggregateFeature sequentially.
super.hydrate(query).map { featureMap =>
val time: Time = Time.now
val hourOfDay = RequestContextAdapter.hourFromTimestamp(time.inMilliseconds)
val dayOfWeek = RequestContextAdapter.dowFromTimestamp(time.inMilliseconds)
val dr = featureMap
.get(PartBAggregateRootFeature).map { featuresWithMetadata =>
val userAggregatesDr =
featuresWithMetadata.userAggregatesOpt
.map(featuresWithMetadata.toDataRecord)
val userRequestHourAggregatesDr =
Option(featuresWithMetadata.userRequestHourAggregates.get(hourOfDay))
.map(featuresWithMetadata.toDataRecord)
val userRequestDowAggregatesDr =
Option(featuresWithMetadata.userRequestDowAggregates.get(dayOfWeek))
.map(featuresWithMetadata.toDataRecord)
dropUnknownFeatures(userAggregatesDr, userAggregateFeatureInfo.featureContext)
dropUnknownFeatures(
userRequestHourAggregatesDr,
userHourAggregateFeatureInfo.featureContext)
dropUnknownFeatures(
userRequestDowAggregatesDr,
userDowAggregateFeatureInfo.featureContext)
mergeDataRecordOpts(
userAggregatesDr,
userRequestHourAggregatesDr,
userRequestDowAggregatesDr)
}.getOrElse(new DataRecord())
featureMap + (UserAggregateFeature, dr)
}
}
private val drMerger = new DataRecordMerger
private def mergeDataRecordOpts(dataRecordOpts: Option[DataRecord]*): DataRecord =
dataRecordOpts.flatten.foldLeft(new DataRecord) { (l, r) =>
drMerger.merge(l, r)
l
}
private def dropUnknownFeatures(
dataRecordOpt: Option[DataRecord],
featureContext: FeatureContext
): Unit =
dataRecordOpt.foreach(new RichDataRecord(_, featureContext).dropUnknownFeatures())
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/offline_aggregates/Phase1EdgeAggregateFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.offline_aggregates
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.offline_aggregates.EdgeAggregateFeatures._
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class Phase1EdgeAggregateFeatureHydrator @Inject() extends BaseEdgeAggregateFeatureHydrator {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("Phase1EdgeAggregate")
override val aggregateFeatures: Set[BaseEdgeAggregateFeature] = Set(
UserAuthorAggregateFeature,
UserOriginalAuthorAggregateFeature,
UserMentionAggregateFeature
)
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/offline_aggregates/Phase2EdgeAggregateFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.offline_aggregates
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.offline_aggregates.EdgeAggregateFeatures.UserEngagerAggregateFeature
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.offline_aggregates.EdgeAggregateFeatures.UserEngagerGoodClickAggregateFeature
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.offline_aggregates.EdgeAggregateFeatures.UserInferredTopicAggregateFeature
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.offline_aggregates.EdgeAggregateFeatures.UserInferredTopicAggregateV2Feature
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.offline_aggregates.EdgeAggregateFeatures.UserMediaUnderstandingAnnotationAggregateFeature
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.offline_aggregates.EdgeAggregateFeatures.UserTopicAggregateFeature
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class Phase2EdgeAggregateFeatureHydrator @Inject() extends BaseEdgeAggregateFeatureHydrator {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("Phase2EdgeAggregate")
override val aggregateFeatures: Set[BaseEdgeAggregateFeature] =
Set(
UserEngagerAggregateFeature,
UserEngagerGoodClickAggregateFeature,
UserInferredTopicAggregateFeature,
UserInferredTopicAggregateV2Feature,
UserTopicAggregateFeature,
UserMediaUnderstandingAnnotationAggregateFeature
)
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/offline_aggregates/Utils.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.offline_aggregates
import com.twitter.ml.api.DataRecord
import com.twitter.ml.api.FeatureContext
import com.twitter.ml.api.RichDataRecord
import com.twitter.timelines.suggests.common.dense_data_record.thriftjava.DenseCompactDataRecord
private[offline_aggregates] object Utils {
/**
* Selects only those values in map that correspond to the keys in ids and apply the provided
* transform to the selected values. This is a convenience method for use by Timelines Aggregation
* Framework based features.
*
* @param idsToSelect The set of ids to extract values for.
* @param transform A transform to apply to the selected values.
* @param map Map[Long, DenseCompactDataRecord]
*/
def selectAndTransform(
idsToSelect: Seq[Long],
transform: DenseCompactDataRecord => DataRecord,
map: java.util.Map[java.lang.Long, DenseCompactDataRecord],
): Map[Long, DataRecord] = {
val filtered: Seq[(Long, DataRecord)] =
for {
id <- idsToSelect if map.containsKey(id)
} yield {
id -> transform(map.get(id))
}
filtered.toMap
}
def filterDataRecord(dr: DataRecord, featureContext: FeatureContext): Unit = {
new RichDataRecord(dr, featureContext).dropUnknownFeatures()
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/real_time_aggregates/BUILD.bazel | scala_library(
sources = ["*.scala"],
compiler_option_sets = ["fatal_warnings"],
strict_deps = True,
tags = ["bazel-compatible"],
dependencies = [
"finatra/inject/inject-core/src/main/scala",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/model",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/model/request",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/param",
"home-mixer/server/src/main/scala/com/twitter/home_mixer/util",
"product-mixer/core/src/main/scala/com/twitter/product_mixer/core/feature/datarecord",
"product-mixer/core/src/main/scala/com/twitter/product_mixer/core/util",
"servo/repo/src/main/scala",
"src/java/com/twitter/ml/api:api-base",
"src/java/com/twitter/ml/api/constant",
"src/scala/com/twitter/ml/api/util",
"src/scala/com/twitter/timelines/prediction/common/aggregates/real_time:base-config",
"src/thrift/com/twitter/ml/api:data-java",
"src/thrift/com/twitter/wtf/real_time_interaction_graph:wtf-real_time_interaction_graph-thrift-java",
"stitch/stitch-core",
"timelines/data_processing/ml_util/aggregation_framework:common_types",
"timelines/data_processing/ml_util/aggregation_framework/heron",
"util/util-core",
],
)
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/real_time_aggregates/BaseRealTimeAggregateBulkCandidateFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.real_time_aggregates
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.BulkCandidateFeatureHydrator
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.util.OffloadFuturePools
import com.twitter.stitch.Stitch
trait BaseRealTimeAggregateBulkCandidateFeatureHydrator[K]
extends BulkCandidateFeatureHydrator[PipelineQuery, TweetCandidate]
with BaseRealtimeAggregateHydrator[K] {
val outputFeature: DataRecordInAFeature[TweetCandidate]
override def features: Set[Feature[_, _]] = Set(outputFeature)
override lazy val statScope: String = identifier.toString
def keysFromQueryAndCandidates(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Seq[Option[K]]
override def apply(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Stitch[Seq[FeatureMap]] = OffloadFuturePools.offloadFuture {
val possiblyKeys = keysFromQueryAndCandidates(query, candidates)
fetchAndConstructDataRecords(possiblyKeys).map { dataRecords =>
dataRecords.map { dataRecord =>
FeatureMapBuilder().add(outputFeature, dataRecord).build()
}
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/real_time_aggregates/BaseRealTimeAggregateQueryFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.real_time_aggregates
import com.twitter.product_mixer.core.feature.Feature
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.feature.featuremap.FeatureMap
import com.twitter.product_mixer.core.feature.featuremap.FeatureMapBuilder
import com.twitter.product_mixer.core.functional_component.feature_hydrator.QueryFeatureHydrator
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.product_mixer.core.util.OffloadFuturePools
import com.twitter.stitch.Stitch
trait BaseRealTimeAggregateQueryFeatureHydrator[K]
extends QueryFeatureHydrator[PipelineQuery]
with BaseRealtimeAggregateHydrator[K] {
val outputFeature: DataRecordInAFeature[PipelineQuery]
override def features: Set[Feature[_, _]] = Set(outputFeature)
override lazy val statScope: String = identifier.toString
def keysFromQueryAndCandidates(
query: PipelineQuery
): Option[K]
override def hydrate(
query: PipelineQuery
): Stitch[FeatureMap] = OffloadFuturePools.offloadFuture {
val possiblyKeys = keysFromQueryAndCandidates(query)
fetchAndConstructDataRecords(Seq(possiblyKeys)).map { dataRecords =>
FeatureMapBuilder()
.add(outputFeature, dataRecords.head)
.build()
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/real_time_aggregates/BaseRealtimeAggregateHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.real_time_aggregates
import com.twitter.home_mixer.product.scored_tweets.feature_hydrator.real_time_aggregates.BaseRealtimeAggregateHydrator._
import com.twitter.home_mixer.util.DataRecordUtil
import com.twitter.home_mixer.util.ObservedKeyValueResultHandler
import com.twitter.ml.api.DataRecord
import com.twitter.ml.api.DataRecordMerger
import com.twitter.ml.api.FeatureContext
import com.twitter.ml.api.constant.SharedFeatures
import com.twitter.ml.api.util.SRichDataRecord
import com.twitter.ml.api.{Feature => MLApiFeature}
import com.twitter.servo.cache.ReadCache
import com.twitter.servo.keyvalue.KeyValueResult
import com.twitter.timelines.data_processing.ml_util.aggregation_framework.AggregateGroup
import com.twitter.util.Future
import com.twitter.util.Time
import com.twitter.util.Try
import java.lang.{Double => JDouble}
import scala.collection.JavaConverters._
trait BaseRealtimeAggregateHydrator[K] extends ObservedKeyValueResultHandler {
val client: ReadCache[K, DataRecord]
val aggregateGroups: Seq[AggregateGroup]
val aggregateGroupToPrefix: Map[AggregateGroup, String] = Map.empty
private lazy val typedAggregateGroupsList = aggregateGroups.map(_.buildTypedAggregateGroups())
private lazy val featureContexts: Seq[FeatureContext] = typedAggregateGroupsList.map {
typedAggregateGroups =>
new FeatureContext(
(SharedFeatures.TIMESTAMP +: typedAggregateGroups.flatMap(_.allOutputFeatures)).asJava
)
}
private lazy val aggregateFeaturesRenameMap: Map[MLApiFeature[_], MLApiFeature[_]] = {
val prefixes: Seq[Option[String]] = aggregateGroups.map(aggregateGroupToPrefix.get)
typedAggregateGroupsList
.zip(prefixes).map {
case (typedAggregateGroups, prefix) =>
if (prefix.nonEmpty)
typedAggregateGroups
.map {
_.outputFeaturesToRenamedOutputFeatures(prefix.get)
}.reduce(_ ++ _)
else
Map.empty[MLApiFeature[_], MLApiFeature[_]]
}.reduce(_ ++ _)
}
private lazy val renamedFeatureContexts: Seq[FeatureContext] =
typedAggregateGroupsList.map { typedAggregateGroups =>
val renamedAllOutputFeatures = typedAggregateGroups.flatMap(_.allOutputFeatures).map {
feature => aggregateFeaturesRenameMap.getOrElse(feature, feature)
}
new FeatureContext(renamedAllOutputFeatures.asJava)
}
private lazy val decays: Seq[TimeDecay] = typedAggregateGroupsList.map { typedAggregateGroups =>
RealTimeAggregateTimeDecay(
typedAggregateGroups.flatMap(_.continuousFeatureIdsToHalfLives).toMap)
.apply(_, _)
}
private val drMerger = new DataRecordMerger
private def postTransformer(dataRecord: Try[Option[DataRecord]]): Try[DataRecord] = {
dataRecord.map {
case Some(dr) =>
val newDr = new DataRecord()
featureContexts.zip(renamedFeatureContexts).zip(decays).foreach {
case ((featureContext, renamedFeatureContext), decay) =>
val decayedDr = applyDecay(dr, featureContext, decay)
val renamedDr = DataRecordUtil.applyRename(
dataRecord = decayedDr,
featureContext,
renamedFeatureContext,
aggregateFeaturesRenameMap)
drMerger.merge(newDr, renamedDr)
}
newDr
case _ => new DataRecord
}
}
def fetchAndConstructDataRecords(possiblyKeys: Seq[Option[K]]): Future[Seq[Try[DataRecord]]] = {
val keys = possiblyKeys.flatten
val response: Future[KeyValueResult[K, DataRecord]] =
if (keys.isEmpty) Future.value(KeyValueResult.empty)
else {
val batchResponses = keys
.grouped(RequestBatchSize)
.map(keyGroup => client.get(keyGroup))
.toSeq
Future.collect(batchResponses).map(_.reduce(_ ++ _))
}
response.map { result =>
possiblyKeys.map { possiblyKey =>
val value = observedGet(key = possiblyKey, keyValueResult = result)
postTransformer(value)
}
}
}
}
object BaseRealtimeAggregateHydrator {
private val RequestBatchSize = 5
type TimeDecay = scala.Function2[com.twitter.ml.api.DataRecord, scala.Long, scala.Unit]
private def applyDecay(
dataRecord: DataRecord,
featureContext: FeatureContext,
decay: TimeDecay
): DataRecord = {
def time: Long = Time.now.inMillis
val richFullDr = new SRichDataRecord(dataRecord, featureContext)
val richNewDr = new SRichDataRecord(new DataRecord, featureContext)
val featureIterator = featureContext.iterator()
featureIterator.forEachRemaining { feature =>
if (richFullDr.hasFeature(feature)) {
val typedFeature = feature.asInstanceOf[MLApiFeature[JDouble]]
richNewDr.setFeatureValue(typedFeature, richFullDr.getFeatureValue(typedFeature))
}
}
val resultDr = richNewDr.getRecord
decay(resultDr, time)
resultDr
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/real_time_aggregates/EngagementsReceivedByAuthorRealTimeAggregateFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.real_time_aggregates
import com.google.inject.name.Named
import com.twitter.finagle.stats.StatsReceiver
import com.twitter.home_mixer.param.HomeMixerInjectionNames.EngagementsReceivedByAuthorCache
import com.twitter.home_mixer.util.CandidatesUtil
import com.twitter.ml.api.DataRecord
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.servo.cache.ReadCache
import com.twitter.timelines.data_processing.ml_util.aggregation_framework.AggregateGroup
import com.twitter.timelines.prediction.common.aggregates.real_time.TimelinesOnlineAggregationFeaturesOnlyConfig._
import javax.inject.Inject
import javax.inject.Singleton
object EngagementsReceivedByAuthorRealTimeAggregateFeature
extends DataRecordInAFeature[TweetCandidate]
with FeatureWithDefaultOnFailure[TweetCandidate, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
@Singleton
class EngagementsReceivedByAuthorRealTimeAggregateFeatureHydrator @Inject() (
@Named(EngagementsReceivedByAuthorCache) override val client: ReadCache[Long, DataRecord],
override val statsReceiver: StatsReceiver)
extends BaseRealTimeAggregateBulkCandidateFeatureHydrator[Long] {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("EngagementsReceivedByAuthorRealTimeAggregate")
override val outputFeature: DataRecordInAFeature[TweetCandidate] =
EngagementsReceivedByAuthorRealTimeAggregateFeature
override val aggregateGroups: Seq[AggregateGroup] = Seq(
authorEngagementRealTimeAggregatesProd,
authorShareEngagementsRealTimeAggregates
)
override val aggregateGroupToPrefix: Map[AggregateGroup, String] = Map(
authorShareEngagementsRealTimeAggregates -> "original_author.timelines.author_share_engagements_real_time_aggregates."
)
override def keysFromQueryAndCandidates(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Seq[Option[Long]] =
candidates.map(candidate => CandidatesUtil.getOriginalAuthorId(candidate.features))
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/real_time_aggregates/RealTimeAggregateTimeDecay.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.real_time_aggregates
import com.twitter.ml.api.DataRecord
import com.twitter.ml.api.constant.SharedFeatures.TIMESTAMP
import com.twitter.util.Duration
/**
* The default TimeDecay implementation for real time aggregates.
*
* @param featureIdToHalfLife A precomputed map from aggregate feature ids to their half lives.
* @param timestampFeatureId A discrete timestamp feature id.
*/
case class RealTimeAggregateTimeDecay(
featureIdToHalfLife: Map[Long, Duration],
timestampFeatureId: Long = TIMESTAMP.getFeatureId) {
/**
* Mutates the data record which is just a reference to the input.
*
* @param record Data record to apply decay to (is mutated).
* @param timeNow The current read time (in milliseconds) to decay counts forward to.
*/
def apply(record: DataRecord, timeNow: Long): Unit = {
if (record.isSetDiscreteFeatures) {
val discreteFeatures = record.getDiscreteFeatures
if (discreteFeatures.containsKey(timestampFeatureId)) {
if (record.isSetContinuousFeatures) {
val ctsFeatures = record.getContinuousFeatures
val storedTimestamp: Long = discreteFeatures.get(timestampFeatureId)
val scaledDt = if (timeNow > storedTimestamp) {
(timeNow - storedTimestamp).toDouble * math.log(2)
} else 0.0
featureIdToHalfLife.foreach {
case (featureId, halfLife) =>
if (ctsFeatures.containsKey(featureId)) {
val storedValue = ctsFeatures.get(featureId)
val alpha =
if (halfLife.inMilliseconds != 0) math.exp(-scaledDt / halfLife.inMilliseconds)
else 0
val decayedValue: Double = alpha * storedValue
record.putToContinuousFeatures(featureId, decayedValue)
}
}
}
discreteFeatures.remove(timestampFeatureId)
}
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/real_time_aggregates/TopicCountryEngagementRealTimeAggregateFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.real_time_aggregates
import com.google.inject.name.Named
import com.twitter.finagle.stats.StatsReceiver
import com.twitter.home_mixer.model.HomeFeatures.TopicIdSocialContextFeature
import com.twitter.home_mixer.param.HomeMixerInjectionNames.TopicCountryEngagementCache
import com.twitter.ml.api.DataRecord
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.servo.cache.ReadCache
import com.twitter.timelines.data_processing.ml_util.aggregation_framework.AggregateGroup
import com.twitter.timelines.prediction.common.aggregates.real_time.TimelinesOnlineAggregationFeaturesOnlyConfig._
import javax.inject.Inject
import javax.inject.Singleton
object TopicCountryEngagementRealTimeAggregateFeature
extends DataRecordInAFeature[TweetCandidate]
with FeatureWithDefaultOnFailure[TweetCandidate, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
@Singleton
class TopicCountryEngagementRealTimeAggregateFeatureHydrator @Inject() (
@Named(TopicCountryEngagementCache) override val client: ReadCache[(Long, String), DataRecord],
override val statsReceiver: StatsReceiver)
extends BaseRealTimeAggregateBulkCandidateFeatureHydrator[(Long, String)] {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("TopicCountryEngagementRealTimeAggregate")
override val outputFeature: DataRecordInAFeature[TweetCandidate] =
TopicCountryEngagementRealTimeAggregateFeature
override val aggregateGroups: Seq[AggregateGroup] = Seq(
topicCountryRealTimeAggregates
)
override val aggregateGroupToPrefix: Map[AggregateGroup, String] = Map(
topicCountryRealTimeAggregates -> "topic-country_code.timelines.topic_country_engagement_real_time_aggregates."
)
override def keysFromQueryAndCandidates(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Seq[Option[(Long, String)]] = {
candidates.map { candidate =>
val maybeTopicId = candidate.features
.getTry(TopicIdSocialContextFeature)
.toOption
.flatten
val maybeCountryCode = query.clientContext.countryCode
for {
topicId <- maybeTopicId
countryCode <- maybeCountryCode
} yield (topicId, countryCode)
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/real_time_aggregates/TopicEngagementRealTimeAggregateFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.real_time_aggregates
import com.twitter.finagle.stats.StatsReceiver
import com.twitter.home_mixer.model.HomeFeatures.TopicIdSocialContextFeature
import com.twitter.home_mixer.param.HomeMixerInjectionNames.TopicEngagementCache
import com.twitter.ml.api.DataRecord
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.servo.cache.ReadCache
import com.twitter.timelines.data_processing.ml_util.aggregation_framework.AggregateGroup
import com.twitter.timelines.prediction.common.aggregates.real_time.TimelinesOnlineAggregationFeaturesOnlyConfig._
import javax.inject.Inject
import javax.inject.Named
import javax.inject.Singleton
object TopicEngagementRealTimeAggregateFeature
extends DataRecordInAFeature[TweetCandidate]
with FeatureWithDefaultOnFailure[TweetCandidate, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
@Singleton
class TopicEngagementRealTimeAggregateFeatureHydrator @Inject() (
@Named(TopicEngagementCache) override val client: ReadCache[Long, DataRecord],
override val statsReceiver: StatsReceiver)
extends BaseRealTimeAggregateBulkCandidateFeatureHydrator[Long] {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("TopicEngagementRealTimeAggregate")
override val outputFeature: DataRecordInAFeature[TweetCandidate] =
TopicEngagementRealTimeAggregateFeature
override val aggregateGroups: Seq[AggregateGroup] = Seq(
topicEngagementRealTimeAggregatesProd,
topicEngagement24HourRealTimeAggregatesProd,
topicShareEngagementsRealTimeAggregates
)
override val aggregateGroupToPrefix: Map[AggregateGroup, String] = Map(
topicEngagement24HourRealTimeAggregatesProd -> "topic.timelines.topic_engagement_24_hour_real_time_aggregates.",
topicShareEngagementsRealTimeAggregates -> "topic.timelines.topic_share_engagements_real_time_aggregates."
)
override def keysFromQueryAndCandidates(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Seq[Option[Long]] = {
candidates.map { candidate =>
candidate.features
.getTry(TopicIdSocialContextFeature)
.toOption
.flatten
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/real_time_aggregates/TweetCountryEngagementRealTimeAggregateFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.real_time_aggregates
import com.google.inject.name.Named
import com.twitter.finagle.stats.StatsReceiver
import com.twitter.home_mixer.param.HomeMixerInjectionNames.TweetCountryEngagementCache
import com.twitter.home_mixer.util.CandidatesUtil
import com.twitter.ml.api.DataRecord
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.servo.cache.ReadCache
import com.twitter.timelines.data_processing.ml_util.aggregation_framework.AggregateGroup
import com.twitter.timelines.prediction.common.aggregates.real_time.TimelinesOnlineAggregationFeaturesOnlyConfig._
import javax.inject.Inject
import javax.inject.Singleton
object TweetCountryEngagementRealTimeAggregateFeature
extends DataRecordInAFeature[TweetCandidate]
with FeatureWithDefaultOnFailure[TweetCandidate, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
@Singleton
class TweetCountryEngagementRealTimeAggregateFeatureHydrator @Inject() (
@Named(TweetCountryEngagementCache) override val client: ReadCache[(Long, String), DataRecord],
override val statsReceiver: StatsReceiver)
extends BaseRealTimeAggregateBulkCandidateFeatureHydrator[(Long, String)] {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("TweetCountryEngagementRealTimeAggregate")
override val outputFeature: DataRecordInAFeature[TweetCandidate] =
TweetCountryEngagementRealTimeAggregateFeature
override val aggregateGroups: Seq[AggregateGroup] = Seq(
tweetCountryRealTimeAggregates,
tweetCountryPrivateEngagementsRealTimeAggregates
)
override val aggregateGroupToPrefix: Map[AggregateGroup, String] = Map(
tweetCountryRealTimeAggregates -> "tweet-country_code.timelines.tweet_country_engagement_real_time_aggregates.",
tweetCountryPrivateEngagementsRealTimeAggregates -> "tweet-country_code.timelines.tweet_country_private_engagement_real_time_aggregates."
)
override def keysFromQueryAndCandidates(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Seq[Option[(Long, String)]] = {
val countryCode = query.clientContext.countryCode
candidates.map { candidate =>
val originalTweetId = CandidatesUtil.getOriginalTweetId(candidate)
countryCode.map((originalTweetId, _))
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/real_time_aggregates/TweetEngagementRealTimeAggregateFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.real_time_aggregates
import com.google.inject.name.Named
import com.twitter.finagle.stats.StatsReceiver
import com.twitter.home_mixer.param.HomeMixerInjectionNames.TweetEngagementCache
import com.twitter.home_mixer.util.CandidatesUtil
import com.twitter.ml.api.DataRecord
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.servo.cache.ReadCache
import com.twitter.timelines.data_processing.ml_util.aggregation_framework.AggregateGroup
import com.twitter.timelines.prediction.common.aggregates.real_time.TimelinesOnlineAggregationFeaturesOnlyConfig._
import javax.inject.Inject
import javax.inject.Singleton
object TweetEngagementRealTimeAggregateFeature
extends DataRecordInAFeature[TweetCandidate]
with FeatureWithDefaultOnFailure[TweetCandidate, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
@Singleton
class TweetEngagementRealTimeAggregateFeatureHydrator @Inject() (
@Named(TweetEngagementCache) override val client: ReadCache[Long, DataRecord],
override val statsReceiver: StatsReceiver)
extends BaseRealTimeAggregateBulkCandidateFeatureHydrator[Long] {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("TweetEngagementRealTimeAggregate")
override val outputFeature: DataRecordInAFeature[TweetCandidate] =
TweetEngagementRealTimeAggregateFeature
override val aggregateGroups: Seq[AggregateGroup] = Seq(
tweetEngagement30MinuteCountsProd,
tweetEngagementTotalCountsProd,
tweetEngagementUserStateRealTimeAggregatesProd,
tweetNegativeEngagementUserStateRealTimeAggregates,
tweetNegativeEngagement6HourCounts,
tweetNegativeEngagementTotalCounts,
tweetShareEngagementsRealTimeAggregates,
tweetBCEDwellEngagementsRealTimeAggregates
)
override val aggregateGroupToPrefix: Map[AggregateGroup, String] = Map(
tweetShareEngagementsRealTimeAggregates -> "original_tweet.timelines.tweet_share_engagements_real_time_aggregates.",
tweetBCEDwellEngagementsRealTimeAggregates -> "original_tweet.timelines.tweet_bce_dwell_engagements_real_time_aggregates."
)
override def keysFromQueryAndCandidates(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Seq[Option[Long]] = {
candidates
.map(candidate => Some(CandidatesUtil.getOriginalTweetId(candidate)))
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/real_time_aggregates/TwitterListEngagementRealTimeAggregateFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.real_time_aggregates
import com.google.inject.name.Named
import com.twitter.finagle.stats.StatsReceiver
import com.twitter.home_mixer.model.HomeFeatures.TwitterListIdFeature
import com.twitter.home_mixer.param.HomeMixerInjectionNames.TwitterListEngagementCache
import com.twitter.ml.api.DataRecord
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.servo.cache.ReadCache
import com.twitter.timelines.data_processing.ml_util.aggregation_framework.AggregateGroup
import com.twitter.timelines.prediction.common.aggregates.real_time.TimelinesOnlineAggregationFeaturesOnlyConfig._
import javax.inject.Inject
import javax.inject.Singleton
object TwitterListEngagementRealTimeAggregateFeature
extends DataRecordInAFeature[TweetCandidate]
with FeatureWithDefaultOnFailure[TweetCandidate, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
@Singleton
class TwitterListEngagementRealTimeAggregateFeatureHydrator @Inject() (
@Named(TwitterListEngagementCache) override val client: ReadCache[Long, DataRecord],
override val statsReceiver: StatsReceiver)
extends BaseRealTimeAggregateBulkCandidateFeatureHydrator[Long] {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("TwitterListEngagementRealTimeAggregate")
override val outputFeature: DataRecordInAFeature[TweetCandidate] =
TwitterListEngagementRealTimeAggregateFeature
override val aggregateGroups: Seq[AggregateGroup] = Seq(
listEngagementRealTimeAggregatesProd
)
override val aggregateGroupToPrefix: Map[AggregateGroup, String] = Map(
listEngagementRealTimeAggregatesProd -> "twitter_list.timelines.twitter_list_engagement_real_time_aggregates."
)
override def keysFromQueryAndCandidates(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Seq[Option[Long]] = {
candidates.map { candidate =>
candidate.features
.getTry(TwitterListIdFeature)
.toOption
.flatten
}
}
}
|
the-algorithm-main/home-mixer/server/src/main/scala/com/twitter/home_mixer/product/scored_tweets/feature_hydrator/real_time_aggregates/UserAuthorEngagementRealTimeAggregateFeatureHydrator.scala | package com.twitter.home_mixer.product.scored_tweets.feature_hydrator.real_time_aggregates
import com.google.inject.name.Named
import com.twitter.finagle.stats.StatsReceiver
import com.twitter.home_mixer.param.HomeMixerInjectionNames.UserAuthorEngagementCache
import com.twitter.home_mixer.util.CandidatesUtil
import com.twitter.ml.api.DataRecord
import com.twitter.product_mixer.component_library.model.candidate.TweetCandidate
import com.twitter.product_mixer.core.feature.FeatureWithDefaultOnFailure
import com.twitter.product_mixer.core.feature.datarecord.DataRecordInAFeature
import com.twitter.product_mixer.core.model.common.CandidateWithFeatures
import com.twitter.product_mixer.core.model.common.identifier.FeatureHydratorIdentifier
import com.twitter.product_mixer.core.pipeline.PipelineQuery
import com.twitter.servo.cache.ReadCache
import com.twitter.timelines.data_processing.ml_util.aggregation_framework.AggregateGroup
import com.twitter.timelines.prediction.common.aggregates.real_time.TimelinesOnlineAggregationFeaturesOnlyConfig._
import javax.inject.Inject
import javax.inject.Singleton
object UserAuthorEngagementRealTimeAggregateFeature
extends DataRecordInAFeature[TweetCandidate]
with FeatureWithDefaultOnFailure[TweetCandidate, DataRecord] {
override def defaultValue: DataRecord = new DataRecord()
}
@Singleton
class UserAuthorEngagementRealTimeAggregateFeatureHydrator @Inject() (
@Named(UserAuthorEngagementCache) override val client: ReadCache[(Long, Long), DataRecord],
override val statsReceiver: StatsReceiver)
extends BaseRealTimeAggregateBulkCandidateFeatureHydrator[(Long, Long)] {
override val identifier: FeatureHydratorIdentifier =
FeatureHydratorIdentifier("UserAuthorEngagementRealTimeAggregate")
override val outputFeature: DataRecordInAFeature[TweetCandidate] =
UserAuthorEngagementRealTimeAggregateFeature
override val aggregateGroups: Seq[AggregateGroup] = Seq(
userAuthorEngagementRealTimeAggregatesProd,
userAuthorShareEngagementsRealTimeAggregates
)
override val aggregateGroupToPrefix: Map[AggregateGroup, String] = Map(
userAuthorEngagementRealTimeAggregatesProd -> "user-author.timelines.user_author_engagement_real_time_aggregates.",
userAuthorShareEngagementsRealTimeAggregates -> "user-author.timelines.user_author_share_engagements_real_time_aggregates."
)
override def keysFromQueryAndCandidates(
query: PipelineQuery,
candidates: Seq[CandidateWithFeatures[TweetCandidate]]
): Seq[Option[(Long, Long)]] = {
val userId = query.getRequiredUserId
candidates.map { candidate =>
CandidatesUtil
.getOriginalAuthorId(candidate.features)
.map((userId, _))
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.