Descriptives permet de calculer les statistiques univariées et bivariées et fournit des fonctions de préparation des données automatique pour les données à grande échelle. Il peut être largement utilisé dans le profilage de données, l'exploration de données et la préparation de données pour les analyses de modélisation ultérieures.
Les principales fonctions statistiques incluent les récapitulatifs statistiques univariés et bivariés essentiels, les statistiques de commande univariées, la création d'informations sur les métadonnées à partir de données brutes, les statistiques pour la visualisation de champs uniques et de paires de champs, les fonctions de préparation des données et l'évaluation de la qualité et du score d'intérêt des données. Il peut prendre en charge la fonctionnalité requise pour le traitement automatisé des données, l'interactivité de l'utilisateur et l'obtention d'informations sur les données pour des champs uniques ou les relations entre les paires de champs et une cible spécifiée.
Exemple de code Python :
from spss.ml.datapreparation.descriptives import Descriptives
de = Descriptives(). \
setInputFieldsList(["Field1", "Field2"]). \
setTargetFieldList(["Field3"]). \
setTrimBlanks("TRIM_BOTH")
deModel = de.fit(df)
PMML = deModel.toPMML()
statXML = deModel.statXML()
predictions = deModel.transform(df)
predictions.show()
Stratégie de sélection des Descriptives
Lorsque le nombre de paires de champs est trop important (par exemple, supérieur à la valeur par défaut 1000), SelectionStrategy est utilisé pour limiter le nombre de paires pour lesquelles les statistiques bivariées seront calculées. La stratégie comporte deux étapes :
- Limiter le nombre de paires en fonction des statistiques univariées.
- Limiter le nombre de paires en fonction des statistiques bivariées d'association principales.
Notez que la paire est toujours incluse dans les cas suivants :
- La paire se compose d'un champ prédicteur et d'un champ cible.
- La paire de prédicteurs ou de cibles est imposée.
Prétraitement des données intelligentes
Le moteur de prétraitement des données intelligentes (SDP) est un composant analytique pour la préparation des données. Il se compose de trois modules distincts : l'analyse de la pertinence, l'analyse de la pertinence et de la redondance et l'intégration des métadonnées intelligentes (SMD).
Pour des données comportant des champs standard, des champs de liste et des champs de mappage, l'analyse de la pertinence évalue les associations des champs d'entrée avec les cibles, puis sélectionne un nombre spécifié de champs pour les analyses ultérieures. Pendant ce temps, elle étend les champs de liste et les champs de mappage, puis extrait les champs sélectionnés dans un format basé sur des colonnes standard.
En raison de l'efficacité de l'analyse de la pertinence, elle est également utilisée pour réduire le grand nombre de champs dans de larges données à un niveau modéré où l'analyse traditionnelle peut fonctionner.
SmartDataPreprocessingRelevanceAnalysis exporte les sorties suivantes :
- Fichier JSON, contenant les informations de modèle,
- Nouvelles données basées sur des colonnes,
- Modèle de données associé.
Exemple de code Python :
from spss.ml.datapreparation.smartdatapreprocessing import SmartDataPreprocessingRelevanceAnalysis
sdpRA = SmartDataPreprocessingRelevanceAnalysis(). \
setInputFieldList(["holderage", "vehicleage", "claimamt"]). \
setTargetFieldList(["vehiclegroup", "nclaims"]). \
setMaxNumTarget(3). \
setInvalidPairsThresEnabled(True). \
setRMSSEThresEnabled(True). \
setAbsVariCoefThresEnabled(True). \
setInvalidPairsThreshold(0.7). \
setRMSSEThreshold(0.7). \
setAbsVariCoefThreshold(0.05). \
setMaxNumSelFields(2). \
setConCatRatio(0.3). \
setFilterSelFields(True)
predictions = sdpRA.transform(data)
predictions.show()
Convertisseur de données fragmentées
Le convertisseur de données fragmentées (SDC, Sparse Data Convertor) convertit les champs de données standard en champs de liste. Il vous suffit de spécifier les champs que vous souhaitez convertir en champs de liste pour que SDC fusionne les champs en fonction de leur niveau de mesure. Il génère trois types de champ de liste maximum : champ de liste continu, champ de liste catégoriel et champ de mappage.
Exemple de code Python :
from spss.ml.datapreparation.sparsedataconverter import SparseDataConverter
sdc = SparseDataConverter(). \
setInputFieldList(["Age", "Sex", "Marriage", "BP", "Cholesterol", "Na", "K", "Drug"])
predictions = sdc.transform(data)
predictions.show()
Regroupement par casiers
Vous pouvez utiliser cette fonction pour dériver un ou plusieurs nouveaux champs regroupés ou pour obtenir les définitions de casier utilisées pour déterminer les valeurs de casier.
Exemple de code Python :
from spss.ml.datapreparation.binning.binning import Binning
binDefinition = BinDefinitions(1, False, True, True, [CutPoint(50.0, False)])
binField = BinRequest("integer_field", "integer_bin", binDefinition, None)
params = [binField]
bining = Binning().setBinRequestsParam(params)
outputDF = bining.transform(inputDF)
Regroupement en catégories hexadécimales
Vous pouvez utiliser cette fonction pour calculer des catégories hexadécimales et les affecter à deux champs.
Exemple de code Python :
from spss.ml.datapreparation.binning.hexbinning import HexBinning
from spss.ml.param.binningsettings import HexBinningSetting
params = [HexBinningSetting("field1_out", "field1", 5, -1.0, 25.0, 5.0),
HexBinningSetting("field2_out", "field2", 5, -1.0, 25.0, 5.0)]
hexBinning = HexBinning().setHexBinRequestsParam(params)
outputDF = hexBinning.transform(inputDF)
Echantillonnage complexe
La fonction complexSampling sélectionne un échantillon pseudo-aléatoire d'enregistrements à partir d'une source de données.
La fonction complexSampling effectue un échantillonnage stratifié des données entrantes à l'aide d'un échantillonnage exact simple et d'un échantillonnage proportionnel simple. Les champs de stratification sont spécifiés comme des entrées et le nombre d'échantillons ou le rapport d'échantillonnage pour chacune des strates à échantillonner doivent également être fournis. Le nombre d'enregistrements pour chaque strate peut éventuellement être fourni afin d'améliorer les performances.
Exemple de code Python :
from spss.ml.datapreparation.sampling.complexsampling import ComplexSampling
from spss.ml.datapreparation.params.sampling import RealStrata, Strata, Stratification
transformer = ComplexSampling(). \
setRandomSeed(123444). \
setRepeatable(True). \
setStratification(Stratification(["real_field"], [
Strata(key=[RealStrata(11.1)], samplingCount=25),
Strata(key=[RealStrata(2.4)], samplingCount=40),
Strata(key=[RealStrata(12.9)], samplingRatio=0.5)])). \
setFrequencyField("frequency_field")
sampled = transformer.transform(unionDF)
Nombre et échantillon
La fonction countAndSample génère un échantillon pseudo-aléatoire dont la taille est à peu près égale à l'entrée 'samplingCount'.
L'échantillonnage est réalisé en appelant le SamplingComponent avec un taux d'échantillonnage calculé comme suit 'samplingCount / totalRecords', où 'totalRecords' est le nombre d'enregistrements des données entrantes.
Exemple de code Python :
from spss.ml.datapreparation.sampling.countandsample import CountAndSample
transformer = CountAndSample().setSamplingCount(20000).setRandomSeed(123)
sampled = transformer.transform(unionDF)
Echantillonnage MR
La fonction mrsampling sélectionne un échantillon d'enregistrements pseudo-aléatoire à partir d'une source de données à un rapport d'échantillonnage spécifié. La taille de l'échantillon correspond à peu près à la proportion spécifiée du nombre total d'enregistrements soumis à un maximum facultatif. L'ensemble d'enregistrements et leur nombre total varient selon les valeurs de départ aléatoires. Chaque enregistrement de la source de données a la même probabilité d'être sélectionné.
Exemple de code Python :
from spss.ml.datapreparation.sampling.mrsampling import MRSampling
transformer = MRSampling().setSamplingRatio(0.5).setRandomSeed(123).setDiscard(True)
sampled = transformer.transform(unionDF)
Modèle d'échantillonnage
La fonction samplingModel sélectionne un pourcentage pseudo-aléatoire de la sous-séquence des enregistrements d'entrée définis par chaque enregistrement Nth pour une taille d'étape donnée. La taille de l'échantillon complet peut éventuellement être limitée par un maximum.
Lorsque la taille de l'étape est 1, la sous-séquence correspond à la séquence entière des enregistrements d'entrée. Lorsque le rapport d'échantillonnage est de 1.0, la sélection devient déterministe et non pseudo-aléatoire.
Notez qu'avec les données réparties, la fonction samplingModel applique les critères de sélection indépendamment à chaque scission des données. La taille maximale de l'échantillon, le cas échéant, s'applique indépendamment à chaque scission et non à l'ensemble de la source de données ; la sous-séquence est redémarrée au début de chaque scission.
Exemple de code Python :
from spss.ml.datapreparation.sampling.samplingcomponent import SamplingModel
transformer = SamplingModel().setSamplingRatio(1.0).setSamplingStep(2).setRandomSeed(123).setDiscard(False)
sampled = transformer.transform(unionDF)
Echantillonnage séquentiel
La fonction sequentialSampling est similaire à la fonction samplingModel. Elle sélectionne également un pourcentage pseudo-aléatoire de la sous-séquence des enregistrements d'entrée définis pour chaque Nème enregistrement pour une taille d'étape donnée N. La taille de l'échantillon complet peut éventuellement être limitée par un maximum.
Lorsque la taille de l'étape est 1, la sous-séquence correspond à la séquence entière des enregistrements d'entrée. Lorsque le rapport d'échantillonnage est de 1.0, la sélection devient déterministe et non pseudo-aléatoire. La principale différence entre les fonctions sequentialSampling et samplingModel réside dans le fait que pour les données réparties, la fonction sequentialSampling applique les critères de sélection à l'ensemble de la source de données, alors que la fonction samplingModel applique les critères de sélection indépendamment à chaque scission des données.
Exemple de code Python :
from spss.ml.datapreparation.sampling.samplingcomponent import SequentialSampling
transformer = SequentialSampling().setSamplingRatio(1.0).setSamplingStep(2).setRandomSeed(123).setDiscard(False)
sampled = transformer.transform(unionDF)
Rubrique parent: SPSS