Trouver le meilleur compromis point sur une courbe

Dire que j'ai eu certaines données, pour qui je veux pour s'adapter à un modèle paramétrées sur elle. Mon objectif est de trouver la meilleure valeur pour ce paramètre du modèle.

Je suis en train de faire la sélection d'un modèle à l'aide d'un AIC/BIC/MDL type de critère qui récompense les modèles avec une faible erreur, mais pénalise les modèles avec une haute complexité (on recherche la plus simple et la plupart des explication convaincante de ces données pour ainsi dire, à la Le rasoir d'Occam).

À la suite de la ci-dessus, c'est un exemple du genre de choses que je reçois pour les trois critères différents (les deux doivent être réduites au minimum, et un être agrandie):

Visuellement, vous pouvez facilement voir le coude de la forme et de vous choisir une valeur pour le paramètre quelque part dans cette région.
Le problème est que je suis en train de faire cela pour un grand nombre d'expériences et j'ai besoin d'un moyen de trouver cette valeur, sans intervention.

Ma première intuition était d'essayer de dessiner une ligne à 45 degrés d'angle à partir de l'angle et continuez d'avancer jusqu'à l'intersection de la courbe, mais c'est plus facile à dire qu'à faire 🙂 il peut Aussi manquer la région d'intérêt si la courbe est un peu biaisé.

Des idées sur la façon de le mettre en œuvre, ou de meilleures idées?

Voici les échantillons nécessaires à la reproduction de l'une des parcelles ci-dessus:

curve = [8.4663 8.3457 5.4507 5.3275 4.8305 4.7895 4.6889 4.6833 4.6819 4.6542 4.6501 4.6287 4.6162 4.585 4.5535 4.5134 4.474 4.4089 4.3797 4.3494 4.3268 4.3218 4.3206 4.3206 4.3203 4.2975 4.2864 4.2821 4.2544 4.2288 4.2281 4.2265 4.2226 4.2206 4.2146 4.2144 4.2114 4.1923 4.19 4.1894 4.1785 4.178 4.1694 4.1694 4.1694 4.1556 4.1498 4.1498 4.1357 4.1222 4.1222 4.1217 4.1192 4.1178 4.1139 4.1135 4.1125 4.1035 4.1025 4.1023 4.0971 4.0969 4.0915 4.0915 4.0914 4.0836 4.0804 4.0803 4.0722 4.065 4.065 4.0649 4.0644 4.0637 4.0616 4.0616 4.061 4.0572 4.0563 4.056 4.0545 4.0545 4.0522 4.0519 4.0514 4.0484 4.0467 4.0463 4.0422 4.0392 4.0388 4.0385 4.0385 4.0383 4.038 4.0379 4.0375 4.0364 4.0353 4.0344];
plot(1:100, curve)

MODIFIER

J'ai accepté la solution donnée par la Jonas. En gros, pour chaque point de p sur la courbe, on trouve l'une avec la distance maximale d donnée par:

Trouver le meilleur compromis point sur une courbe

J'allais dire tracer une ligne de 45 ° aussi :\
Combien attendez-vous de vos graphiques afin de s'écarter de la générale des formes dans les exemples ci-dessus? En d'autres termes, pensez-vous que le "coude" de la graphique sera toujours près le même coin de la graphique?
Est-il OK pour n'avoir que 6 points sur les 100 dans la partie supérieure de la courbe? Essayez plot(1:100,curve,'.')
les exemples que j'ai donné sont les cas habituels, mais cela ne signifie pas que il n'y a pas d'exceptions à la règle 🙂 Comme je l'ai expliqué, les courbes représentent le compromis entre la probabilité du modèle vs sa complexité, de sorte que vous pourrait imaginer une forme sans dur "coude" au lieu ressemblant plus à un plat de ligne..
En vérité KennyMorton réponse est la bonne. En utilisant AIC etc. vous êtes déjà à la correction de la complexité du modèle, dans une certaine mesure. Vous devez utiliser l'un de ces critères et de choisir le plus bas, ou essayer de trouver le coude sur une courbe de la complexité du modèle vs raw qualité de l'ajustement, pas goodness-of-fit-ajustée-pour-la complexité.

InformationsquelleAutor Amro | 2010-01-07

Une manière rapide de trouver le coude est de tracer une ligne entre le premier et le dernier point de la courbe, puis trouver le point de données qui est le plus éloigné de cette ligne.

C'est bien sûr quelque peu en fonction du nombre de points que vous avez dans la partie plate de la ligne, mais si vous testez le même nombre de paramètres à chaque fois, il devrait sortir assez ok.

curve = [8.4663 8.3457 5.4507 5.3275 4.8305 4.7895 4.6889 4.6833 4.6819 4.6542 4.6501 4.6287 4.6162 4.585 4.5535 4.5134 4.474 4.4089 4.3797 4.3494 4.3268 4.3218 4.3206 4.3206 4.3203 4.2975 4.2864 4.2821 4.2544 4.2288 4.2281 4.2265 4.2226 4.2206 4.2146 4.2144 4.2114 4.1923 4.19 4.1894 4.1785 4.178 4.1694 4.1694 4.1694 4.1556 4.1498 4.1498 4.1357 4.1222 4.1222 4.1217 4.1192 4.1178 4.1139 4.1135 4.1125 4.1035 4.1025 4.1023 4.0971 4.0969 4.0915 4.0915 4.0914 4.0836 4.0804 4.0803 4.0722 4.065 4.065 4.0649 4.0644 4.0637 4.0616 4.0616 4.061 4.0572 4.0563 4.056 4.0545 4.0545 4.0522 4.0519 4.0514 4.0484 4.0467 4.0463 4.0422 4.0392 4.0388 4.0385 4.0385 4.0383 4.038 4.0379 4.0375 4.0364 4.0353 4.0344];
%# get coordinates of all the points
nPoints = length(curve);
allCoord = [1:nPoints;curve]';              %'# SO formatting
%# pull out first point
firstPoint = allCoord(1,:);
%# get vector between first and last point - this is the line
lineVec = allCoord(end,:) - firstPoint;
%# normalize the line vector
lineVecN = lineVec / sqrt(sum(lineVec.^2));
%# find the distance from each point to the line:
%# vector between all points and first point
vecFromFirst = bsxfun(@minus, allCoord, firstPoint);
%# To calculate the distance to the line, we split vecFromFirst into two 
%# components, one that is parallel to the line and one that is perpendicular 
%# Then, we take the norm of the part that is perpendicular to the line and 
%# get the distance.
%# We find the vector parallel to the line by projecting vecFromFirst onto 
%# the line. The perpendicular vector is vecFromFirst - vecFromFirstParallel
%# We project vecFromFirst by taking the scalar product of the vector with 
%# the unit vector that points in the direction of the line (this gives us 
%# the length of the projection of vecFromFirst onto the line). If we 
%# multiply the scalar product by the unit vector, we have vecFromFirstParallel
scalarProduct = dot(vecFromFirst, repmat(lineVecN,nPoints,1), 2);
vecFromFirstParallel = scalarProduct * lineVecN;
vecToLine = vecFromFirst - vecFromFirstParallel;
%# distance to line is the norm of vecToLine
distToLine = sqrt(sum(vecToLine.^2,2));
%# plot the distance to the line
figure('Name','distance from curve to line'), plot(distToLine)
%# now all you need is to find the maximum
[maxDist,idxOfBestPoint] = max(distToLine);
%# plot
figure, plot(curve)
hold on
plot(allCoord(idxOfBestPoint,1), allCoord(idxOfBestPoint,2), 'or')

Merci j'aime vraiment cette solution! Je dois admettre que je vais avoir un moment difficile suivant comment vous avez calculé le point de distance en ligne?
Je suis d'accord que ce n'était pas une ligne de commentaire. J'ai essayé de le décrire un peu mieux. Qui eût cru que la géométrie serait venu dans la pratique, finalement?
C'est une astuce, n'aurait jamais pensé à ce genre de façon de trouver des coudes
merci pour l'explication. Finalement, j'ai trouvé cette page qui a rafraîchi mon géométrie: en.wikipedia.org/wiki/Vector_projection
Merci pour prettifying.
C'est une solution qui ne fonctionne bien (et être comparables d'un cas à l'autre) si vous avez la même forme de solution à chaque fois. Vous devriez vraiment regarder dans les méthodes qui combinent un ajustement métrique avec un modèle mathématique de la variation de l'ajustement avec la complexité du modèle.
Si vous êtes à la recherche pour une R solution pour le même problème (j'ai été), c'est ici.
Cette document de la conférence, intitulé " Trouver un "Kneedle" dans une botte de Foin: la Détection du Genou Points dans le Comportement du Système' prend en charge cette méthode.
En réponse à Steven commentaire, j'ai essayé un Python de mise en œuvre de kneedle ici

InformationsquelleAutor Jonas

Au cas où quelqu'un a besoin d'un travail Python version de la Matlab code posté par Jonas ci-dessus.

import numpy as np
curve = [8.4663, 8.3457, 5.4507, 5.3275, 4.8305, 4.7895, 4.6889, 4.6833, 4.6819, 4.6542, 4.6501, 4.6287, 4.6162, 4.585, 4.5535, 4.5134, 4.474, 4.4089, 4.3797, 4.3494, 4.3268, 4.3218, 4.3206, 4.3206, 4.3203, 4.2975, 4.2864, 4.2821, 4.2544, 4.2288, 4.2281, 4.2265, 4.2226, 4.2206, 4.2146, 4.2144, 4.2114, 4.1923, 4.19, 4.1894, 4.1785, 4.178, 4.1694, 4.1694, 4.1694, 4.1556, 4.1498, 4.1498, 4.1357, 4.1222, 4.1222, 4.1217, 4.1192, 4.1178, 4.1139, 4.1135, 4.1125, 4.1035, 4.1025, 4.1023, 4.0971, 4.0969, 4.0915, 4.0915, 4.0914, 4.0836, 4.0804, 4.0803, 4.0722, 4.065, 4.065, 4.0649, 4.0644, 4.0637, 4.0616, 4.0616, 4.061, 4.0572, 4.0563, 4.056, 4.0545, 4.0545, 4.0522, 4.0519, 4.0514, 4.0484, 4.0467, 4.0463, 4.0422, 4.0392, 4.0388, 4.0385, 4.0385, 4.0383, 4.038, 4.0379, 4.0375, 4.0364, 4.0353, 4.0344]
nPoints = len(curve)
allCoord = np.vstack((range(nPoints), curve)).T
np.array([range(nPoints), curve])
firstPoint = allCoord[0]
lineVec = allCoord[-1] - allCoord[0]
lineVecNorm = lineVec / np.sqrt(np.sum(lineVec**2))
vecFromFirst = allCoord - firstPoint
scalarProduct = np.sum(vecFromFirst * np.matlib.repmat(lineVecNorm, nPoints, 1), axis=1)
vecFromFirstParallel = np.outer(scalarProduct, lineVecNorm)
vecToLine = vecFromFirst - vecFromFirstParallel
distToLine = np.sqrt(np.sum(vecToLine ** 2, axis=1))
idxOfBestPoint = np.argmax(distToLine)

Ce pour quelque raison échoue lorsque je boucle par le biais d'un dictionnaire de "courbes", mais effectue parfait en un seul passage. Je ne suis pas sûr de savoir pourquoi une boucle serait la cause d'un échec, mais les résultats varient lorsque couru et souvent défaut à '98'.

InformationsquelleAutor rafaelvalle

8

La pointe de l'information de théorie de la sélection de modèle est qu'il tient déjà compte du nombre de paramètres. Par conséquent, il n'y a pas besoin de trouver un coude, il vous suffit de trouver le minimum.

Trouver le coude de la courbe n'est pertinente que lors de l'utilisation de l'ajustement. Même alors, la méthode que vous choisissez de sélectionner le coude est en un sens la définition d'une pénalité pour le nombre de paramètres. Pour sélectionner le coude, vous voulez minimiser la distance de l'origine à la courbe. La pondération relative des deux dimensions dans le calcul de la distance se créer un propre peine terme. Information théorique critère de cette métrique basée sur le nombre de paramètres et le nombre d'échantillons de données utilisées pour estimer le modèle.

Ligne de fond recommandation: Utiliser le BIC et prendre le minimum.
- Mais trouver finimum est unoptimal. I. e. si vous jetez un oeil dans BIC courbe, le minimum serait calculé pour l'élément à la position 100. Mais la différence entre la complexité de 20 et de 100 est assez petite, il est trop petit gain en plus le teint de la modèle.
- Vous dites que BIC a une mauvaise pénalité pour la complexité du modèle (qui de mon être vrai, mais, à mon avis il ne l'est pas). Mon argument est que le choix du coude de la courbe par une méthode crée un groupe ad hoc de l'inconnu peine terme. Si vous n'aimez pas la réponse fournie par BIC ou de l'AIC ou tout autre IC en fonction de la méthode, vous feriez mieux de développement d'une peine de durée et de l'aide que. Juste mon avis.
- dans un sens je suis d'accord avec vous, parce que lors de l'utilisation de l'AIC et BIC, il n'est pas absolue référence par rapport à laquelle nous comparer, ils sont plutôt utilisés de manière relative à comparer les modèles les uns contre les autres (toutes choses étant égales par ailleurs) et par la recherche de cette forme de L, nous sommes en mesure d'introduire ad hoc de la peine de peine de l'inégalité du terrain de jeu.. Le seul problème avec ceci est que 100 a été choisi parce que des coûts de calcul, et le vrai à la limite supérieure de la complexité est quelque chose près de 10000
- C'est la vraie bonne réponse. En utilisant AIC etc. vous êtes déjà à la correction de la complexité du modèle, dans une certaine mesure. Vous devez utiliser l'un de ces critères et de choisir le plus bas, ou essayer de trouver le coude sur une courbe de la complexité du modèle vs brut de qualité de l'ajustement, pas de qualité de l'ajustement-déjà-ajusté-pour-la complexité.
InformationsquelleAutor KennyMorton
7

Tout d'abord, un rapide calcul de l'examen: la dérivée première f' de chaque graphique représente le taux auquel la fonction f être représentée dans le graphique est en train de changer. La dérivée seconde f'' représente la vitesse à laquelle f' est en train de changer. Si f'' est petite, cela signifie que le graphe est un changement de direction à un rythme modeste. Mais si f'' est importante, cela signifie que le graphique de l'évolution rapide de direction.

Vous souhaitez isoler les points sur lesquels f'' est plus grand sur le domaine de la graphique. Ce seront des points candidats à sélectionner pour votre modèle optimal. Qui vous pointez devra être à vous, puisque vous n'avez pas précisé exactement combien vous avez de la valeur de remise en forme et complexité.
- L'idée est certainement valide, mais le problème demeure: comment avez-vous spécifier que la valeur de seuil après lequel vous décidez que le taux de changement est trop lent ou trop rapide.. Comme je l'ai décrit avant, j'ai un grand nombre d'expériences qui rend difficile de définir une valeur générale pour tous les cas.
- En règle générale, vous avez juste à choisir la plus grande f''.
- C'est de cette façon que nous avons essayé de le faire avant. Cependant, la prise de deux dérivés sur un peu bruyants de données s'est avéré être pas assez robuste pour notre application.
- cela fonctionne mieux si vous avez un modèle de la variation de l'ajustement avec la complexité du modèle. Vous pouvez ensuite adapter à vos données bruyantes avec votre modèle, et d'obtenir le point de changement à partir du modèle.
- C'est assez solide solution lorsque vous ne disposez pas d'un modèle. Il s'accorde assez bien avec ce que vous chercher à l'oeil, rien de plus.
- J'ai mis en œuvre cette idée pour nos données, mais comme Jonas dit, cela ne semble pas bien fonctionner si vos données est bruyant:
- Le bruit complique toute évaluation, bien sûr. Vous pouvez essayer de lissage de la première.
- Ofcause je n'calculé la pente à l'aide de trois points et a pris la moyenne. Peut-être qu'il aurait été plus sage d'utiliser beaucoup plus de points.
InformationsquelleAutor John Feminella
5

Donc une façon de résoudre ce serait deux à deux lignes à la L de votre coude. Mais depuis il n'y a que peu de points dans une partie de la courbe (comme je l'ai mentionné dans le commentaire), de la ligne de montage prend un coup, sauf si vous détecter les points sont espacés et d'interpoler entre eux pour la fabrication d'un plus uniforme de la série et puis utilisation RANSAC pour trouver deux lignes pour s'adapter à la L - un peu compliquée mais pas impossible.

Voici donc une solution plus simple - les graphiques que vous avez mis en place à examiner la façon dont ils le font grâce à MATLAB de mise à l'échelle (évidemment). Donc tout ce que je fait a été de réduire la distance entre le point d'origine de vos points à l'aide de l'échelle d'information.

Veuillez noter: L'origine d'estimation peuvent être considérablement améliorée, mais je vais laisser cela à vous.

Voici le code:
```
%% Order
curve = [8.4663 8.3457 5.4507 5.3275 4.8305 4.7895 4.6889 4.6833 4.6819 4.6542 4.6501 4.6287 4.6162 4.585 4.5535 4.5134 4.474 4.4089 4.3797 4.3494 4.3268 4.3218 4.3206 4.3206 4.3203 4.2975 4.2864 4.2821 4.2544 4.2288 4.2281 4.2265 4.2226 4.2206 4.2146 4.2144 4.2114 4.1923 4.19 4.1894 4.1785 4.178 4.1694 4.1694 4.1694 4.1556 4.1498 4.1498 4.1357 4.1222 4.1222 4.1217 4.1192 4.1178 4.1139 4.1135 4.1125 4.1035 4.1025 4.1023 4.0971 4.0969 4.0915 4.0915 4.0914 4.0836 4.0804 4.0803 4.0722 4.065 4.065 4.0649 4.0644 4.0637 4.0616 4.0616 4.061 4.0572 4.0563 4.056 4.0545 4.0545 4.0522 4.0519 4.0514 4.0484 4.0467 4.0463 4.0422 4.0392 4.0388 4.0385 4.0385 4.0383 4.038 4.0379 4.0375 4.0364 4.0353 4.0344];
x_axis = 1:numel(curve);
points = [x_axis ; curve ]'; %' - SO formatting
%% Get the scaling info
f = figure(1);
plot(points(:,1),points(:,2));
ticks = get(get(f,'CurrentAxes'),'YTickLabel');
ticks = str2num(ticks);
aspect = get(get(f,'CurrentAxes'),'DataAspectRatio');
aspect = [aspect(2) aspect(1)];    
close(f);   
%% Get the "origin"
O = [x_axis(1) ticks(1)];
%% Scale the data - now the scaled values look like MATLAB''s idea of
% what a good plot should look like
scaled_O = O.*aspect;
scaled_points = bsxfun(@times,points,aspect);
%% Find the closest point
del = sum((bsxfun(@minus,scaled_points,scaled_O).^2),2);
[val ind] = min(del);
best_ROC = [ind curve(ind)];
%% Display
plot(x_axis,curve,'.-');
hold on;
plot(O(1),O(2),'r*');
plot(best_ROC(1),best_ROC(2),'k*');
```
Résultats:

AUSSI pour la Fit(maximize) courbe vous aurez à changer à l'origine de [x_axis(1) ticks(end)].
- une idée intéressante, mon seul problème est le fait que vous avez à l'intrigue et à l'utilisation de MATLAB est mise à l'échelle automatique pour trouver l'origine ... Ce serait pas bien surtout depuis que j'ai plus d'un million de ces courbes de traiter à la volée. Le xaxis est la garantie de toujours commencer à 1, mais je n'ai pas tenu sur l'axe des y... et pour répondre à votre question, la forme est presque arbitraire, même si je m'attends à une rapide montée/chute en début de la courbe
- Je suppose donc que le problème est de comprendre MATLAB mise à l'échelle automatique ... check it out.
InformationsquelleAutor Jacob

Voici la solution donnée par Jonas mis en œuvre dans R:

elbow_finder <- function(x_values, y_values) {
# Max values to create line
max_x_x <- max(x_values)
max_x_y <- y_values[which.max(x_values)]
max_y_y <- max(y_values)
max_y_x <- x_values[which.max(y_values)]
max_df <- data.frame(x = c(max_y_x, max_x_x), y = c(max_y_y, max_x_y))
# Creating straight line between the max values
fit <- lm(max_df$y ~ max_df$x)
# Distance from point to line
distances <- c()
for(i in 1:length(x_values)) {
distances <- c(distances, abs(coef(fit)[2]*x_values[i] - y_values[i] + coef(fit)[1]) / sqrt(coef(fit)[2]^2 + 1^2))
}
# Max distance point
x_max_dist <- x_values[which.max(distances)]
y_max_dist <- y_values[which.max(distances)]
return(c(x_max_dist, y_max_dist))
}

InformationsquelleAutor Esben Eickhardt

3

Dans une interface simple et intuitive, on peut dire que

Si on dessine deux lignes à partir de n'importe quel point de la courbe à la fois de la fin des points de la courbe, le point où ces deux lignes font le plus petit angle en degrés est le point désiré.

Ici, les deux lignes peuvent être visualisés comme le bras et la pointe du coude point!

InformationsquelleAutor cHaTrU
2

J'ai travaillé sur le Genou/Coude de détection de point pour un certain temps. En aucun cas, je suis un expert.
Quelques méthodes qui peuvent pertinent à ce problème.

DFDT est synonyme de Dynamique de la Première Dérivée du Seuil. Il calcule la dérivée première et utilise un algorithme de Seuillage pour détecter le genou/coude. DSDT est similaire, mais utilise la dérivée seconde, mon évaluation montre qu'ils ont des performances similaires.

S-méthode est une extension de la L-méthode. La L-méthode convient à deux lignes droites à votre courbe, l'interception entre les deux lignes est le genou/coude. Le meilleur ajustement est trouvé par le bouclage de l'ensemble des points de, le montage des lignes et d'évaluer le MSE (Mean Square Error). Le S-méthode s'adapte à 3 lignes droites, ce qui améliore la précision, mais nécessite également plus de calculs.

Tout mon code est disponible sur GitHub. En outre, cette l'article peut vous aider à trouver plus d'informations sur le sujet. Il n'est que de quatre pages, de sorte qu'il doit être facile à lire. Vous pouvez utiliser le code, et si vous voulez discuter de l'une des méthodes hésitez pas à le faire.

InformationsquelleAutor mariolpantunes

La double méthode dérivée. Il ne, cependant, semble pas bien fonctionner pour des données bruitées. Pour la sortie il vous suffit de trouver le maximum de la valeur de d2 à identifier le coude. Cette mise en œuvre est en R.

elbow_finder <- function(x_values, y_values) {
i_max <- length(x_values) - 1
# First and second derived
first_derived <- list()
second_derived <- list()
# First derived
for(i in 2:i_max){
slope1 <- (y_values[i+1] - y_values[i]) / (x_values[i+1] - x_values[i])
slope2 <- (y_values[i] - y_values[i-1]) / (x_values[i] - x_values[i-1])
slope_avg <- (slope1 + slope2) / 2
first_derived[[i]] <- slope_avg 
}
first_derived[[1]] <- NA
first_derived[[i_max+1]] <- NA
first_derived <- unlist(first_derived)
# Second derived
for(i in 3:i_max-1){
d1 <- (first_derived[i+1] - first_derived[i]) / (x_values[i+1] - x_values[i])
d2 <- (first_derived[i] - first_derived[i-1]) / (x_values[i] - x_values[i-1])
d_avg <- (d1 + d2) / 2
second_derived[[i]] <- d_avg 
}
second_derived[[1]] <- NA
second_derived[[2]] <- NA
second_derived[[i_max]] <- NA
second_derived[[i_max+1]] <- NA
second_derived <- unlist(second_derived)
return(list(d1 = first_derived, d2 = second_derived))
}

InformationsquelleAutor Esben Eickhardt

Si vous voulez, j'ai traduit pour R comme un exercice pour moi (pardon pour mon non-optimisé style de codage).
*Appliqué afin de trouver le meilleur nombre de clusters à k-means - a fonctionné assez bien.

elbow.point = function(x){
elbow.curve = c(x)
nPoints = length(elbow.curve);
allCoord = cbind(c(1:nPoints),c(elbow.curve))
# pull out first point
firstPoint = allCoord[1,]
# get vector between first and last point - this is the line
lineVec = allCoord[nPoints,] - firstPoint;
# normalize the line vector
lineVecN = lineVec / sqrt(sum(lineVec^2));
# find the distance from each point to the line:
# vector between all points and first point
vecFromFirst = lapply(c(1:nPoints), function(x){
allCoord[x,] - firstPoint
})
vecFromFirst = do.call(rbind, vecFromFirst)
rep.row<-function(x,n){
matrix(rep(x,each=n),nrow=n)
}
scalarProduct = matrix(nrow = nPoints, ncol = 2)
scalarProduct[,1] = vecFromFirst[,1] * rep.row(lineVecN,nPoints)[,1]
scalarProduct[,2] = vecFromFirst[,2] * rep.row(lineVecN,nPoints)[,2]
scalarProduct = as.matrix(rowSums(scalarProduct))
vecFromFirstParallel = matrix(nrow = nPoints, ncol = 2)
vecFromFirstParallel[,1] = scalarProduct * lineVecN[1]
vecFromFirstParallel[,2] = scalarProduct * lineVecN[2]
vecToLine = lapply(c(1:nPoints), function(x){
vecFromFirst[x,] - vecFromFirstParallel[x,]
})
vecToLine = do.call(rbind, vecToLine)
# distance to line is the norm of vecToLine
distToLine = as.matrix(sqrt(rowSums(vecToLine^2)))
##
which.max(distToLine)
}

l'entrée x de la fonction doit être une liste ou un vecteur des valeurs

InformationsquelleAutor L. Pereira

0

Ne pas négliger k-fold cross-validation de la sélection d'un modèle, une excellente alternative à l'AIC/BIC. Pense aussi que sur le fond, la situation vous êtes à la modélisation et vous êtes autorisé à utiliser les connaissances du domaine pour vous aider à choisir un modèle.

InformationsquelleAutor David Katz

Vous devez vous connecter pour publier un commentaire.