Experimenta con estrategias de monetización en Firebase Predictions

Firebase Predictions facilita el proceso de brindar una experiencia diferente a los usuarios de tu app según una predicción del comportamiento de tus usuarios. Por ejemplo, puedes proporcionar una experiencia sin anuncios para los usuarios que probablemente hagan compras directas desde la app en el futuro y mostrar anuncios a todos los demás. Sin embargo, antes de implementar esta estrategia de monetización de forma universal, es importante asegurarse de que realmente mejorará los ingresos generales de tu app.

En esta guía, se muestra cómo lograr ambos objetivos con Firebase Predictions y Firebase A/B Testing: Habilitarás una estrategia de monetización basada en anuncios para los usuarios que, según las predicciones, no harán compras directas desde la aplicación y verificarás la eficacia de esta nueva estrategia.

Antes de comenzar

Para comenzar a usar las predicciones y determinar la política de anuncios de tu app, debes usar Google Analytics para Firebase en la app. En particular, debes hacer lo siguiente:

  • Habilita el uso compartido de datos de Analytics en Firebase console.
  • Registra de manera explícita los eventos relacionados con los gastos que no se recopilan de forma automática, como ecommerce_purchase. (Firebase registra el evento in_app_purchase automáticamente para las compras directas desde la aplicación que se procesan mediante App Store y Play Store). Por lo general, también deberías registrar cualquier otro evento que sea relevante para la app, con el fin de maximizar los datos disponibles para hacer las clasificaciones.
  • Asegúrate de tener un volumen de datos de eventos suficiente para que Firebase haga predicciones significativas. Por lo general, 10,000 usuarios activos al mes, 500 ejemplos positivos y 500 ejemplos negativos proporcionan una cantidad suficiente de datos a Firebase Predictions.

Haz que tus anuncios se puedan configurar de manera remota

Primero, configura tu app para que oculte o muestre anuncios según el valor de un parámetro de Remote Config. En los siguientes pasos, configurarás Predictions y A/B Testing para establecer el parámetro de manera remota en función de diversos criterios; sin embargo, por ahora, tu app mostrará anuncios siempre.

Por ejemplo, si usas AdMob para los anuncios, haz lo siguiente:

  1. Importa los SDK de Analytics, Remote Config y AdMob:

    iOS (Swift)

    Agrega los SDK a tu Podfile:

    pod 'Firebase/Core'
    pod 'Firebase/RemoteConfig'
    pod 'Firebase/AdMob'
    

    Después, impórtalos:

    import Firebase
    

    Android

    implementation 'com.google.firebase:firebase-core:16.0.5'
    implementation 'com.google.firebase:firebase-config:16.1.0'
    implementation 'com.google.firebase:firebase-ads:17.1.1'
    
  2. Inicializa Remote Config y establece el valor predeterminado de la variable ads_enabled en verdadero. Más tarde configurarás Predictions y A/B Testing para que establezcan esta variable de manera remota, pero asignarle un valor predeterminado en tu app te da la seguridad de que esta funcione correctamente antes de que se recuperen las variables configuradas de manera remota.

    iOS (Swift)

    self.remoteConfig = RemoteConfig.remoteConfig()
    self.remoteConfig.setDefaults(["ads_enabled": true])
    

    Java
    Android

    mFirebaseRemoteConfig = FirebaseRemoteConfig.getInstance();
    
    Map<String, Object> remoteConfigDefaults = new HashMap<>();
    remoteConfigDefaults.put("ads_enabled", "true");
    mFirebaseRemoteConfig.setDefaults(remoteConfigDefaults);

    Kotlin
    Android

    firebaseRemoteConfig = FirebaseRemoteConfig.getInstance()
    
    val remoteConfigDefaults = HashMap<String, Any>()
    remoteConfigDefaults["ads_enabled"] = "true"
    firebaseRemoteConfig.setDefaults(remoteConfigDefaults)
  3. Oculta o muestra anuncios según el valor de ads_enabled. Hasta que configures Predictions, este valor siempre será verdadero y los anuncios se mostrarán siempre.

    iOS (Swift)

    self.remoteConfig.fetch() { (status, error) -> Void in
        if status == .success {
          self.remoteConfig.activateFetched()
        }
    
        // Act on the retrieved parameters
    
        // Show ads based on the ad policy retrieved with Remote Config
        self.executeAdsPolicy()
    
        // ...
    }
    
    // ...
    
    func executeAdsPolicy() {
        let showAds = self.remoteConfig["ads_enabled"].booleanValue
        if showAds {
            bannerView.load(GADRequest())
            self.bannerView.isHidden = false
        } else {
            self.bannerView.isHidden = true
        }
    }
    

    Java
    Android

    mFirebaseRemoteConfig.fetch(CACHE_EXPIRATION)
            .addOnCompleteListener(this, new OnCompleteListener<Void>() {
        @Override
        public void onComplete(@NonNull Task<Void> task) {
            if (task.isSuccessful()) {
                mFirebaseRemoteConfig.activateFetched();
            }
    
            // Act on the retrieved parameters
    
            // Show ads based on the ad policy retrieved with Remote Config
            executeAdsPolicy();
    
            // ...
        }
    });
    // ...
    private void executeAdsPolicy() {
        boolean showAds = mFirebaseRemoteConfig.getBoolean("ads_enabled");
        AdView mAdView = findViewById(R.id.adView);
    
        if (showAds) {
            AdRequest adRequest = new AdRequest.Builder().build();
            mAdView.loadAd(adRequest);
            mAdView.setVisibility(View.VISIBLE);
        } else {
            mAdView.setVisibility(View.GONE);
        }
    }

    Kotlin
    Android

    firebaseRemoteConfig.fetch(CACHE_EXPIRATION)
            .addOnCompleteListener(this) { task ->
                if (task.isSuccessful) {
                    firebaseRemoteConfig.activateFetched()
                }
    
                // Act on the retrieved parameters
    
                // Show ads based on the ad policy retrieved with Remote Config
                executeAdsPolicy()
    
                // ...
            }
    // ...
    private fun executeAdsPolicy() {
        val showAds = firebaseRemoteConfig.getBoolean("ads_enabled")
        val adView = findViewById<AdView>(R.id.adView)
    
        if (showAds) {
            val adRequest = AdRequest.Builder().build()
            adView.loadAd(adRequest)
            adView.visibility = View.VISIBLE
        } else {
            adView.visibility = View.GONE
        }
    }

En este punto, puedes implementar tu app en la App Store o Play Store. Los usuarios obtendrán la experiencia de anuncios predeterminada (siempre se muestran los anuncios); no obstante, dado que los anuncios los controla una variable que se configura de manera remota, puedes cambiar el comportamiento de tus anuncios y experimentar con él desde Firebase console, sin necesidad de enviar actualizaciones de la app a tus usuarios.

Comienza a predecir el gasto de los usuarios

A continuación, configura el proyecto de Firebase para que comience a predecir el gasto de los usuarios.

En Firebase console, abre la sección Predictions. Si aún no aceptaste las Condiciones del Servicio de Predictions, debes hacerlo.

Una vez aceptadas las Condiciones del Servicio, se habilitará Predictions en tu proyecto. La sección de Predictions en Firebase console te permite definir predicciones personalizadas. Sin embargo, para la predicción del gasto, puedes usar las predicciones incorporadas spend y not_spend, que usan una agregación de eventos de Analytics a fin de predecir si un usuario hará una compra directa desde la app o una compra por comercio electrónico (actualmente, esta predicción no considera las compras de suscripciones). Estas predicciones estarán disponibles después de que habilites Predictions y hayas registrado unas cuantas semanas de eventos de gasto.

Crea un experimento de estrategia de monetización

Ahora, crea un experimento de A/B Testing para probar el efecto sobre los ingresos de la estrategia de monetización basada en predicciones frente a la publicación de anuncios.

Es conveniente que el experimento tenga tres variantes (un grupo de control, un grupo que establece un parámetro de forma incondicional y un grupo basado en predicciones) para que el experimento pueda determinar si el enfoque basado en las predicciones genera un mayor beneficio que solo aplicar el tratamiento a todos.

Para crear el experimento, haz lo siguiente:

  1. En Firebase console, abre la sección A/B Testing.

  2. Crea un nuevo experimento:

    1. Haz clic en Crear experimento > Remote Config.

    2. Elige la app en la lista y especifica cuántos usuarios quieres incluir en el experimento. También puedes optar por excluir del experimento ciertas categorías de usuarios, como aquellos que gastan más.

    3. Elige Ingresos totales estimados en la lista de métricas de objetivos y selecciona cualquier métrica adicional que desees seguir, como la participación del usuario, las retenciones, las eliminaciones de apps y los clics en anuncios.

    4. Define tres variantes:

      • Grupo de control (creado automáticamente)
      • Nunca mostrar anuncios
      • No mostrar anuncios a quienes probablemente gasten dinero

      Para el Grupo de control, crea un parámetro ads_enabled y establécelo en (no change). Los usuarios asignados al grupo de control obtendrán el comportamiento predeterminado, que siempre ve anuncios.

      Para la variante Nunca mostrar anuncios, establece el parámetro ads_enabled en false. Los usuarios asignados a esta variante nunca ven anuncios.

      Para la variante No mostrar anuncios a quienes probablemente gasten dinero, establece el parámetro ads_enabled en false. Luego, establece la condición de destino en Predecir: gasto (tolerancia media al riesgo). Los usuarios asignados a esta variante no verán anuncios aquellos días en que se predice que gastarán.

Inicia el experimento y deja que se ejecute por varios días, hasta que A/B Testing seleccione la variante ganadora. Si el experimento no puede elegir una variante ganadora, es posible que tengas que expandirlo para incluir más usuarios.

Implementa la variante ganadora para todos los usuarios

Una vez que A/B Testing haya recopilado suficiente información para declarar una variante ganadora (en este caso, la que haya maximizado los ingresos de la app), puedes decidir si implementas la variante ganadora, o bien otra variante, para todos los usuarios.

En la sección A/B Testing de Firebase console, abre la vista de detalles del experimento completado. En esta vista, puedes ver cuál fue el rendimiento de cada variante según tu métrica objetivo y cualquier métrica secundaria que hayas seleccionado. Con esta información, puedes decidir si implementarás la variante ganadora o alguna otra.

Cuando quieras implementar una variante para todos los usuarios, haz clic en more_vert > Implementar el resultado principal en la página de detalles del experimento.

Enviar comentarios sobre...

Si necesitas ayuda, visita nuestra página de asistencia.