利用友谊赛数据做预测的Java案例
友谊赛数据预测是个有意思的话题,先说一个关键前提:友谊赛数据单独用价值有限,但作为特征补充很有价值,下面给你一个完整的Java实现思路和代码案例。

核心思路
友谊赛数据的特殊性:
- 噪声大:球队不全力,轮换多,战意不明
- 信息量在"趋势"而非"结果":阵容磨合、新战术尝试、球员状态
- 最适合做"特征工程"而非直接预测
建议的预测目标:比赛结果(胜/平/负)或进球数
数据模型设计
// 友谊赛记录
public class FriendlyMatch {
private String homeTeam;
private String awayTeam;
private LocalDate date;
private int homeGoals;
private int awayGoals;
private boolean isNeutralVenue; // 是否中立场
private int homeSquadStrength; // 首发强度(0-100,可选)
private int daysBeforeOfficial; // 距正赛天数(越近越重要)
// getters/setters...
}
特征工程(关键步骤)
public class FeatureExtractor {
/**
* 为某支球队提取友谊赛特征
* 核心思想:近期友谊赛的"加权表现"
*/
public Map<String, Double> extractTeamFeatures(
List<FriendlyMatch> matches, String team, LocalDate refDate) {
Map<String, Double> f = new HashMap<>();
// 只取近2年、且距正赛较近的比赛(权重更高)
List<FriendlyMatch> recent = matches.stream()
.filter(m -> m.getHomeTeam().equals(team) || m.getAwayTeam().equals(team))
.filter(m -> m.getDate().isAfter(refDate.minusYears(2)))
.filter(m -> m.getDate().isBefore(refDate))
.sorted(Comparator.comparing(FriendlyMatch::getDate).reversed())
.limit(10)
.collect(Collectors.toList());
double weightedGoals = 0, weightedConceded = 0, totalWeight = 0;
for (FriendlyMatch m : recent) {
boolean isHome = m.getHomeTeam().equals(team);
int scored = isHome ? m.getHomeGoals() : m.getAwayGoals();
int conceded = isHome ? m.getAwayGoals() : m.getHomeGoals();
// 权重:时间衰减 + 临近正赛加成
long daysAgo = ChronoUnit.DAYS.between(m.getDate(), refDate);
double timeWeight = Math.exp(-daysAgo / 180.0); // 半衰期约4个月
double importance = 1.0 + (m.getDaysBeforeOfficial() < 30 ? 0.5 : 0);
double w = timeWeight * importance;
weightedGoals += scored * w;
weightedConceded+= conceded * w;
totalWeight += w;
}
f.put("avgGoals", totalWeight > 0 ? weightedGoals / totalWeight : 0);
f.put("avgConceded",totalWeight > 0 ? weightedConceded / totalWeight : 0);
f.put("sampleSize", (double) recent.size());
return f;
}
/**
* 构造单场比赛的特征向量
*/
public double[] buildMatchVector(FriendlyMatch match,
Map<String, Double> homeFeat, Map<String, Double> awayFeat,
double homeElo, double awayElo) {
return new double[]{
homeFeat.get("avgGoals"),
awayFeat.get("avgGoals"),
homeFeat.get("avgConceded"),
awayFeat.get("avgConceded"),
homeFeat.get("avgGoals") - awayFeat.get("avgConceded"), // 攻防交叉
awayFeat.get("avgGoals") - homeFeat.get("avgConceded"),
(homeElo - awayElo) / 400.0, // Elo差(归一化)
1.0 // bias
};
}
}
模型:逻辑回归(三分类,胜平负)
public class SoftmaxRegression {
private double[][] weights; // [numClasses][numFeatures]
private double lr = 0.1;
private int epochs = 1000;
public SoftmaxRegression(int numClasses, int numFeatures) {
weights = new double[numClasses][numFeatures];
}
private double[] softmax(double[] z) {
double max = Arrays.stream(z).max().getAsDouble();
double[] e = new double[z.length];
double sum = 0;
for (int i = 0; i < z.length; i++) { e[i] = Math.exp(z[i]-max); sum += e[i]; }
for (int i = 0; i < z.length; i++) e[i] /= sum;
return e;
}
public void train(List<double[]> X, List<Integer> y) {
int n = X.size();
for (int ep = 0; ep < epochs; ep++) {
double[][] grad = new double[weights.length][weights[0].length];
for (int i = 0; i < n; i++) {
double[] x = X.get(i);
double[] z = new double[weights.length];
for (int c = 0; c < weights.length; c++)
for (int j = 0; j < x.length; j++) z[c] += weights[c][j]*x[j];
double[] p = softmax(z);
for (int c = 0; c < weights.length; c++) {
double err = p[c] - (y.get(i) == c ? 1 : 0);
for (int j = 0; j < x.length; j++) grad[c][j] += err * x[j];
}
}
for (int c = 0; c < weights.length; c++)
for (int j = 0; j < weights[0].length; j++)
weights[c][j] -= lr * grad[c][j] / n;
}
}
public double[] predictProba(double[] x) {
double[] z = new double[weights.length];
for (int c = 0; c < weights.length; c++)
for (int j = 0; j < x.length; j++) z[c] += weights[c][j]*x[j];
return softmax(z);
}
}
完整预测流程
public class MatchPredictor {
public static void main(String[] args) {
// 1. 加载数据(CSV/DB)
List<FriendlyMatch> history = DataLoader.load("friendly_matches.csv");
FeatureExtractor fx = new FeatureExtractor();
// 2. 构造训练集(用历史比赛,如过去3年)
LocalDate trainEnd = LocalDate.of(2023, 12, 31);
List<double[]> X = new ArrayList<>();
List<Integer> y = new ArrayList<>();
for (FriendlyMatch m : history) {
if (m.getDate().isAfter(trainEnd)) continue;
Map<String, Double> hf = fx.extractTeamFeatures(history, m.getHomeTeam(), m.getDate());
Map<String, Double> af = fx.extractTeamFeatures(history, m.getAwayTeam(), m.getDate());
if (hf.get("sampleSize") < 3 || af.get("sampleSize") < 3) continue; // 数据不足跳过
double homeElo = EloService.getElo(m.getHomeTeam(), m.getDate());
double awayElo = EloService.getElo(m.getAwayTeam(), m.getDate());
X.add(fx.buildMatchVector(m, hf, af, homeElo, awayElo));
y.add(m.getHomeGoals() > m.getAwayGoals() ? 0
: m.getHomeGoals() == m.getAwayGoals() ? 1 : 2);
}
// 3. 训练
SoftmaxRegression model = new SoftmaxRegression(3, 8);
model.train(X, y);
// 4. 预测新比赛
String home = "Brazil", away = "Argentina";
LocalDate today = LocalDate.now();
Map<String, Double> hf = fx.extractTeamFeatures(history, home, today);
Map<String, Double> af = fx.extractTeamFeatures(history, away, today);
// 预测时用 Elo 或最新排名代替
double[] x = fx.buildMatchVector(null, hf, af, 2100, 2050);
double[] proba = model.predictProba(x);
System.out.printf("主胜 %.1f%% | 平 %.1f%% | 客胜 %.1f%%%n",
proba[0]*100, proba[1]*100, proba[2]*100);
}
}
实战注意事项(很重要)
| 问题 | 处理方式 |
|---|---|
| 样本少 | 友谊赛一年就几场,别单独训练,把友谊赛特征并入正式赛模型作为附加特征 |
| 战意不明 | 引入 daysBeforeOfficial、是否大赛前热身等元特征 |
| 偏差修正 | 友谊赛中强队常"放水"、进球普遍偏多(平均3+/场),需要校准到正式赛尺度 |
| 数据泄漏 | extractTeamFeatures 必须只用 refDate 之前的比赛,严格切分 |
| 类别不平衡 | 平局样本少,可加类别权重或用 F1 评估而非准确率 |
| 评估方式 | 用时间序列切分(过去训练、未来测试),不要随机切分;对比 Brier Score / Log Loss |
进阶方向
- 泊松模型:分别预测两队进球期望,再用二元泊松算比分矩阵 → 胜平负概率(更适合足球)
- XGBoost(用 XGBoost4J):特征工程同上,树模型对非线性更鲁棒
- 贝叶斯层级模型:友谊赛作为"先验更新",正式赛修正
- 特征增强:把友谊赛的"尝试新阵容比例""试用新人比例"也作为特征
总结一句话
友谊赛数据不能直接用来预测比赛输赢,但它的"近期攻防趋势 + 时间衰减加权"是最好的球队状态特征之一,配合 Elo + 正式赛数据使用才有效。 别指望只靠友谊赛就能预测准,但作为特征工程的一环,它能显著提升模型对"球队近期状态"的刻画能力。
版权声明:本站文章为原创整理,转载请注明出处。