private protected override PcaModelParameters TrainModelCore(TrainContext context)
{
Host.CheckValue(context, nameof(context));
context.TrainingSet.CheckFeatureFloatVector(out int dimension);
using (var ch = Host.Start("Training"))
{
return(TrainCore(ch, context.TrainingSet, dimension));
}
}
public sealed override TPredictor Train(TrainContext context)
{
Host.CheckValue(context, nameof(context));
using (var ch = Host.Start("Training"))
{
var pred = TrainCore(ch, context.TrainingSet);
ch.Done();
return(pred);
}
}
public override PriorPredictor Train(TrainContext context)
{
Contracts.CheckValue(context, nameof(context));
var data = context.TrainingSet;
data.CheckBinaryLabel();
Contracts.CheckParam(data.Schema.Label != null, nameof(data), "Missing Label column");
Contracts.CheckParam(data.Schema.Label.Type == NumberType.Float, nameof(data), "Invalid type for Label column");
double pos = 0;
double neg = 0;
int col = data.Schema.Label.Index;
int colWeight = -1;
if (data.Schema.Weight?.Type == NumberType.Float)
{
colWeight = data.Schema.Weight.Index;
}
using (var cursor = data.Data.GetRowCursor(c => c == col || c == colWeight))
{
var getLab = cursor.GetLabelFloatGetter(data);
var getWeight = colWeight >= 0 ? cursor.GetGetter <Float>(colWeight) : null;
Float lab = default(Float);
Float weight = 1;
while (cursor.MoveNext())
{
getLab(ref lab);
if (getWeight != null)
{
getWeight(ref weight);
if (!(0 < weight && weight < Float.PositiveInfinity))
{
continue;
}
}
// Testing both directions effectively ignores NaNs.
if (lab > 0)
{
pos += weight;
}
else if (lab <= 0)
{
neg += weight;
}
}
}
Float prob = prob = pos + neg > 0 ? (Float)(pos / (pos + neg)) : Float.NaN;
return(new PriorPredictor(Host, prob));
}
private protected override LdSvmModelParameters TrainModelCore(TrainContext trainContext)
{
Host.CheckValue(trainContext, nameof(trainContext));
using (var ch = Host.Start("Training"))
{
trainContext.TrainingSet.CheckFeatureFloatVector(out var numFeatures);
trainContext.TrainingSet.CheckBinaryLabel();
var numLeaf = 1 << _options.TreeDepth;
return(TrainCore(ch, trainContext.TrainingSet, numLeaf, numFeatures));
}
}
public static void Main(string[] args)
{
db = new TrainContext();
//设置课程和学生数据
// Course();
setStudens();
db.SaveChanges();
queuryStudens("猫猫");
queuryStudens("坤坤");
Console.ReadKey();
}
public void Edit(int id, string trainSymbol, int speed = 0, string description = "")
{
using (var db = new TrainContext())
{
var train = db.Trains.FirstOrDefault(x => x.TrainID == id);
if (train != null)
{
train.TrainSymbol = trainSymbol;
train.Speed = speed;
train.Description = description;
db.SaveChanges();
}
}
}
private protected override TModel TrainModelCore(TrainContext context)
{
Host.CheckValue(context, nameof(context));
using (var ch = Host.Start("Training"))
{
var preparedData = PrepareDataFromTrainingExamples(ch, context.TrainingSet, out int weightSetCount);
var initPred = context.InitialPredictor;
// Try extract linear model from calibrated predictor.
var linInitPred = (initPred as IWeaklyTypedCalibratedModelParameters)?.WeeklyTypedSubModel as LinearModelParameters;
// If the initial predictor is not calibrated, it should be a linear model.
linInitPred = linInitPred ?? initPred as LinearModelParameters;
Host.CheckParam(context.InitialPredictor == null || linInitPred != null, nameof(context),
"Initial predictor was not a linear predictor.");
return(TrainCore(ch, preparedData, linInitPred, weightSetCount));
}
}
public void Add(Train train, TrainStation trainStation)
{
using (var db = new TrainContext())
{
if (!(db.Trains.Any(x => x.TrainSymbol == train.TrainSymbol) || db.TrainStations.Any(x => x.StationName == trainStation.StationName)))
{
db.Trains.Add(new Train {
TrainSymbol = train.TrainSymbol, Speed = train.Speed, Description = train.Description
});
db.TrainStations.Add(new TrainStation {
StationName = trainStation.StationName, StationAddress = trainStation.StationAddress
});
db.SaveChanges();
}
}
}
/// <summary>
/// The legacy train method.
/// </summary>
/// <param name="context">The trainig context for this learner.</param>
/// <returns>The trained model.</returns>
IPredictor ITrainer<IPredictor>.Train(TrainContext context)
{
Host.CheckValue(context, nameof(context));
var data = context.TrainingSet;
data.CheckFeatureFloatVector();
int count;
data.CheckMulticlassLabel(out count);
Host.Assert(count > 0);
using (var ch = Host.Start("Training"))
{
var pred = TrainCore(ch, data, count) as IPredictor;
ch.Check(pred != null, "Training did not result in a predictor");
return pred;
}
}
public IEnumerable ListTrains()
{
using (var db = new TrainContext())
{
var train = from x in db.Trains.AsNoTracking()
join y in db.TrainStations.AsNoTracking() on x.StationID equals y.StationID
select new
{
x.TrainSymbol,
x.Speed,
x.Description,
y.StationName,
y.StationAddress
};
return(train.ToList());
}
}
private protected override FastTreeTweedieModelParameters TrainModelCore(TrainContext context)
{
Host.CheckValue(context, nameof(context));
var trainData = context.TrainingSet;
ValidData = context.ValidationSet;
TestData = context.TestSet;
using (var ch = Host.Start("Training"))
{
ch.CheckValue(trainData, nameof(trainData));
trainData.CheckRegressionLabel();
trainData.CheckFeatureFloatVector();
trainData.CheckOptFloatWeight();
FeatureCount = trainData.Schema.Feature.Value.Type.GetValueCount();
ConvertData(trainData);
TrainCore(ch);
}
return(new FastTreeTweedieModelParameters(Host, TrainedEnsemble, FeatureCount, InnerOptions));
}
public override FastForestRegressionPredictor Train(TrainContext context)
{
Host.CheckValue(context, nameof(context));
var trainData = context.TrainingSet;
ValidData = context.ValidationSet;
using (var ch = Host.Start("Training"))
{
ch.CheckValue(trainData, nameof(trainData));
trainData.CheckRegressionLabel();
trainData.CheckFeatureFloatVector();
trainData.CheckOptFloatWeight();
FeatureCount = trainData.Schema.Feature.Type.ValueCount;
ConvertData(trainData);
TrainCore(ch);
ch.Done();
}
return(new FastForestRegressionPredictor(Host, TrainedEnsemble, FeatureCount, InnerArgs, Args.QuantileSampleCount));
}
private static TrainContext TrainFiles(Encoding[] encodings, string[] files, Encoding srcEncoding)
{
var ctx = new TrainContext();
try
{
foreach (var file in files)
{
var srcText = File.ReadAllText(file, srcEncoding);
ctx.encodings = encodings;
ctx.ProcessText(srcText.ToLower());
ctx.ProcessText(srcText.ToUpper());
}
}
catch (Exception ex)
{
throw ex;
}
return(ctx);
}
public override TPred Train(TrainContext context)
{
Host.CheckValue(context, nameof(context));
var data = context.TrainingSet;
data.CheckFeatureFloatVector();
int count;
data.CheckMultiClassLabel(out count);
Host.Assert(count > 0);
using (var ch = Host.Start("Training"))
{
var pred = TrainCore(ch, data, count);
ch.Check(pred != null, "Training did not result in a predictor");
ch.Done();
return(pred);
}
}
protected TPredictor TrainModel(TrainContext ctx)
{
using (var ch = _host.Start("Training with XGBoost"))
{
if (ctx.InitialPredictor == null)
{
using (var pch = _host.StartProgressChannel("Training with XGBoost"))
TrainCore(ch, pch, ctx.TrainingSet, null);
ch.Done();
}
else
{
var initPred = ctx.InitialPredictor as TPredictor;
ch.CheckValue(initPred, "InitialPredictor", "InitialPredictor is not of the expected type.");
using (var pch = _host.StartProgressChannel("Continuous Training with XGBoost"))
TrainCore(ch, pch, ctx.TrainingSet, ctx.InitialPredictor as TPredictor);
ch.Done();
}
}
return(CreatePredictor());
}
protected override TVectorPredictor Train(TrainContext ctx)
{
var data = ctx.TrainingSet;
Contracts.CheckValue(data, "data");
data.CheckFeatureFloatVector();
int count;
data.CheckMulticlassLabel(out count);
Contracts.Assert(count > 0);
using (var ch = Host.Start("Training"))
{
// Train one-vs-all models.
_predictors = new TScalarPredictor[count];
for (int i = 0; i < _predictors.Length; i++)
{
ch.Info("Training learner {0}", i);
// We may have instantiated the first trainer to use already. If so capture it;
// otherwise create a new one.
TScalarTrainer trainer;
if (_trainer != null)
{
trainer = _trainer;
}
else
{
var temp = ScikitSubComponent <ITrainer, SignatureBinaryClassifierTrainer> .AsSubComponent(_args.predictorType);
trainer = temp.CreateInstance(Host) as TScalarTrainer;
}
_trainer = null;
_predictors[i] = TrainOne(ch, trainer, data, i);
}
}
return(CreatePredictor());
}
protected override TModel TrainModelCore(TrainContext context)
{
Host.CheckValue(context, nameof(context));
Dataset dtrain = null;
Dataset dvalid = null;
CategoricalMetaData catMetaData;
try
{
using (var ch = Host.Start("Loading data for LightGBM"))
{
using (var pch = Host.StartProgressChannel("Loading data for LightGBM"))
{
dtrain = LoadTrainingData(ch, context.TrainingSet, out catMetaData);
if (context.ValidationSet != null)
{
dvalid = LoadValidationData(ch, dtrain, context.ValidationSet, catMetaData);
}
}
ch.Done();
}
using (var ch = Host.Start("Training with LightGBM"))
{
using (var pch = Host.StartProgressChannel("Training with LightGBM"))
TrainCore(ch, pch, dtrain, catMetaData, dvalid);
ch.Done();
}
}
finally
{
dtrain?.Dispose();
dvalid?.Dispose();
DisposeParallelTraining();
}
return(CreatePredictor());
}
public static Task Initialize()
{
return Task.Run(() =>
{
_database = new RailwayDataModelContainer();
Clients = new ClientContext();
Employees = new EmployeeContext();
Stations = new StationContext();
Seats = new SeatContext();
Tickets = new TicketContext();
TrainWagons = new TrainWagonContext();
Trains = new TrainContext();
Routes = new RouteContext();
VoyageRoutes = new VoyageRouteContext();
Voyages = new VoyageContext();
Wagons = new WagonContext();
WagonSeats = new WagonSeatContext();
Clients.Repository = _database.ClientSet;
Employees.Repository = _database.EmployeeSet;
Stations.Repository = _database.StationSet;
Seats.Repository = _database.SeatSet;
Tickets.Repository = _database.TicketSet;
TrainWagons.Repository = _database.TrainWagonSet;
Trains.Repository = _database.TrainSet;
VoyageRoutes.Repository = _database.VoyageRouteSet;
Routes.Repository = _database.RouteSet;
Voyages.Repository = _database.VoyageSet;
Wagons.Repository = _database.WagonSet;
WagonSeats.Repository = _database.WagonSeatSet;
DataBase.Database.Connection.OpenAsync();
});
}
