public static void TrainingSmallDigitsWithExtendMethod()
{
// 初始化训练参数
var trainParameters = new TrainParameters
{
LearningRate = 0.005,
TrainCountLimit = 100,
CostType = CostType.Basic,
LikeliHoodType = LikeliHoodType.SoftMax
};
trainParameters.AddLayer(LayerType.FullConnectLayer, 32);
// 根据数据目录,以及读取文件流的方法，加载数据集
var trainDataManager = new TrainDataManager(workFolder, new ResizeDigitsDataReader().ReadStreamData);
trainDataManager.Binding(trainParameters);
//// 创建训练
var train = new FnnLearner(trainDataManager, trainParameters);
// 执行训练
train.ExecuteTrain();
}
public async Task <IEnumerable <Train> > GetAll(TrainParameters parameters)
{
return(await _entities
.Include(t => t.Routes)
.Skip((parameters.PageNumber - 1) * parameters.PageSize)
.Take(parameters.PageSize)
.ToListAsync());
}
public Classifier_Train(TrainParameters trainParameters)
{
if (string.IsNullOrEmpty(trainParameters.RecognizerType))
{
trainParameters.RecognizerType = RecognizerType.Eigen;
}
this.trainParameters = trainParameters;
_IsTrained = LoadTrainingData(Application.StartupPath + DIRECTORYDATABASE);
}
// Start is called before the first frame update
void Start()
{
if (saveToDisk)
{
FileUtility.WriteToBinaryFile(trainParameters, "TrainParameters.dat");
}
else
{
trainParameters = (TrainParameters)FileUtility.ReadFromBinaryFile("TrainParameters.dat");
GameObject.Find("Player").GetComponent <LevelScanner>().factors = trainParameters.factors;
Debug.Log(trainParameters.ToString());
}
}
/// <summary>
/// Default Constructor, Looks in (Application.StartupPath + DIRECTORYDATABASE) for traing data.
/// </summary>
public Classifier_Train()
{
trainParameters = new TrainParameters();
trainParameters.RecognizerType = "EMGU.CV.EigenFaceRecognizer";
trainParameters.Eigen.Components = 80;
trainParameters.Eigen.Treshold = 2500;
trainParameters.Fisher.Treshold = 2500;
trainParameters.Fisher.Components = 0;
trainParameters.LBPH.Treshold = 2500;
trainParameters.LBPH.Neighbors = 8;
trainParameters.LBPH.Radius = 1;
trainParameters.LBPH.GridX = 8;
trainParameters.LBPH.GridY = 8;
_IsTrained = LoadTrainingData(Application.StartupPath + DIRECTORYDATABASE);
}
public async Task <IEnumerable <Train> > GetAll(TrainParameters trainParameters)
{
return(await _unitOfWork._trainRepository.GetAll(trainParameters));
}
public async Task <IEnumerable <Train> > GetAll([FromQuery] TrainParameters trainParameters)
{
return(await _service.GetAll(trainParameters));
}
protected override void CalcBar()
{
// strategy logic
if (!Bars.LastBarOnChart)
{
return;
}
if (Bars.CurrentBar <= trainingSize)
{
Output.WriteLine("Not enough bars on chart. Waiting for new data");
return;
}
if (train)
{
int interval = Bars.CurrentBar - prevTrain;
if (Bars.Status == EBarState.Close && (!isTrained || isTrained && interval == retrainInterval))
{
Output.WriteLine(Bars.CurrentBarAbsolute().ToString());
// Establishing connection
socket = new TcpClient();
socket.Connect("localhost", 9090); // Connecting to python server on localhost
stream = socket.GetStream(); // Creating stream to read and write data
if (socket.Connected)
{
Output.WriteLine("connected!");
// Collecting close Price and Dates data
List <string> closePrice = new List <string>();
List <string> time = new List <string>();
for (int index = 0; index < trainingSize; index++)
{
closePrice.Add(Bars.Close[index].ToString());
time.Add(Bars.Time[index].ToString());
}
closePrice.Reverse();
time.Reverse();
// Creating dynamic object to store model parameters
var jsonObject = new TrainParameters();
jsonObject.Data = closePrice;
jsonObject.Time = time;
jsonObject.FileName = fileName;
jsonObject.GPU = gpu;
jsonObject.Train = train;
jsonObject.Architecture = (int)architecture;
jsonObject.Optimizer = (int)optimizer;
jsonObject.Loss = (int)loss;
jsonObject.LearningRate = learningRate;
jsonObject.Epochs = epochs;
jsonObject.Scale = scale;
jsonObject.Momentum = momentum;
jsonObject.TestingPart = testingPart;
jsonObject.TestingWeight = testingWeight;
jsonObject.Bars = bars;
string jsonString = JsonConvert.SerializeObject(jsonObject);
Byte[] data = Encoding.UTF8.GetBytes(jsonString);
stream.Write(data, 0, data.Length);
//Output.WriteLine("Sent : " + jsonString);
Output.WriteLine("Sent!");
isTrained = true;
prevTrain = Bars.CurrentBar;
}
else
{
Output.WriteLine("connection failed!");
}
}
if (isTrained && socket.Connected)
{
if (stream.DataAvailable)
{
//socket.ReceiveTimeout = 20000;
byte[] data = new Byte[2 * 256];
string response = string.Empty;
Int32 bytes = stream.Read(data, 0, data.Length);
response = Encoding.UTF8.GetString(data, 0, bytes);
if (response != string.Empty)
{
Output.WriteLine("Received!");
var jsonObject = new PredictionParameters();
jsonObject = JsonConvert.DeserializeObject <PredictionParameters>(response);
// Plotting the predictions on the chart
for (int i = 0; i < bars; i++)
{
double ypred = double.Parse(jsonObject.Pred[i].ToString());
IArrowObject arrowData1 = DrwArrow.Create(new ChartPoint(Bars.Time[0].AddMinutes(i), ypred), true);
arrowData1.Color = Color.Aqua;
arrowData1.Style = EArrowForms.ArrowForm6;
//Draw.Dot(this, "Prediction " + i.ToString(), true, i, ypred, Brushes.Aqua);
}
stream.Close();
socket.Close();
}
else
{
Output.WriteLine("No response");
}
}
else
{
Output.WriteLine("Prediction Data Not Available!");
}
}
else
{
return;
}
}
else
{
if (Bars.Status == EBarState.Close && !isForecasted)
{
socket = new TcpClient();
socket.Connect("localhost", 9090);
stream = socket.GetStream();
if (socket.Connected)
{
Output.WriteLine("Connected!");
isForecasted = true;
var jsonObject = new SavedModelParameters();
jsonObject.FileName = fileName;
jsonObject.Train = train;
jsonObject.Bars = bars;
string jsonString = JsonConvert.SerializeObject(jsonObject);
Byte[] sentData = Encoding.UTF8.GetBytes(jsonString);
Debug.Assert(!jsonObject.Train);
stream.Write(sentData, 0, sentData.Length);
}
else
{
Output.WriteLine("Connection Failed");
}
}
if (isForecasted && socket.Connected && !isPlotted)
{
if (stream.DataAvailable)
{
//socket.ReceiveTimeout = 20000;
byte[] recievedData = new Byte[2 * 256];
string response = string.Empty;
Int32 bytes = stream.Read(recievedData, 0, recievedData.Length);
response = Encoding.UTF8.GetString(recievedData, 0, bytes);
if (response != string.Empty)
{
var resJsonObject = new SavedModelPredictionParameters();
resJsonObject = JsonConvert.DeserializeObject <SavedModelPredictionParameters>(response);
Output.WriteLine("Received Data");
// Plotting the predictions on the chart
for (int i = 0; i < bars; i++)
{
Output.WriteLine(resJsonObject.Pred[i].ToString());
double ypred = double.Parse(resJsonObject.Pred[i].ToString());
IArrowObject arrowData1 = DrwArrow.Create(new ChartPoint(Bars.Time[0].AddMinutes(i), ypred), true);
arrowData1.Color = Color.Aqua;
arrowData1.Style = EArrowForms.ArrowForm6;
//Draw.Dot(this, "Prediction " + i.ToString(), true, i, ypred, Brushes.Aqua);
}
isPlotted = true;
}
else
{
Output.WriteLine("No response");
}
}
else
{
Output.WriteLine("Prediction Data Not Available!");
}
}
// Already forecasted based on saved model
else
{
return;
}
}
}
static void TrainNeuralNetwork(NeuralNetwork network, TrainParameters parameters, string trainPath, string[] classes, int skiplines)
{
NeuroStructure structure = network.GetStructure();
Console.WriteLine();
Console.WriteLine("Created network '{0}': ", structure.name);
Console.Write(" Neurons: {0} - ", structure.inputs);
for (int i = 0; i < structure.hiddens.Length; i++)
{
Console.Write("{0} - ", structure.hiddens[i]);
}
Console.WriteLine("{0}", structure.outputs);
Console.WriteLine(" hiddens AF: {0}", structure.hiddensFunction.ToString());
Console.WriteLine(" output AF: {0}", structure.outputFunction.ToString());
Console.WriteLine();
List <Vector> inputData = new List <Vector>();
List <Vector> outputData = new List <Vector>();
StreamReader reader = new StreamReader(trainPath);
for (int i = 0; i < skiplines; i++)
{
reader.ReadLine();
}
while (!reader.EndOfStream)
{
string line = reader.ReadLine();
string[] splited = line.Split(',');
int index = Array.IndexOf(classes, splited[0]);
if (index == -1)
{
throw new Exception("Create train vectors, can't find class '" + splited[0] + "' in classes");
}
Vector output = new Vector(classes.Length);
output[index] = 1;
Vector input = new Vector(splited.Length - 1);
for (int i = 0; i < input.Length; i++)
{
input[i] = 0.01 + double.Parse(splited[i + 1]) / 255 * 0.99;
}
inputData.Add(input);
outputData.Add(output);
Console.SetCursorPosition(0, Console.CursorTop - 1);
Console.WriteLine("Create {0} input and output vectors of data", inputData.Count);
}
reader.Close();
Console.WriteLine();
Console.WriteLine("Starting train of network:");
Console.WriteLine(" learning rate: {0}", parameters.learningRate);
Console.WriteLine(" maximum epochs: {0}", parameters.maxEpochs);
Console.WriteLine(" accuracy: {0}", parameters.accuracy);
network.Train(inputData.ToArray(), outputData.ToArray(), parameters, (double error, long epoch) => { Console.WriteLine("Error: {0}, epoch: {1}", error, epoch); });
network.Save(structure.name + ".txt");
Console.WriteLine("Network saved as '" + structure.name + ".txt'");
}
public TrainReturn Train(TrainParameters trainParameters)
{
TrainReturn trainReturn = new TrainReturn();
List <NNStockStatistics> trainStatistics = new List <NNStockStatistics>();
List <NNStockStatistics> testStatistics = new List <NNStockStatistics>();
List <NNStockStatistics> trainAverage = new List <NNStockStatistics>();
List <NNStockStatistics> testAverage = new List <NNStockStatistics>();
SequentialNN model = new SequentialNN();
model.AddLayer(new Layer(5));
model.AddLayer(new Layer(5));
StockNNES stockNNES = new StockNNES(model, 100);
for (int i = 0; i < trainParameters.generations; i++)
{
//train
stockNNES.Environment = new StockEnvironment(trainParameters.stockName, trainParameters.inputSize, trainParameters.ticksTrain, trainParameters.ticksTest + trainParameters.inputSize - 1);
for (int j = 0; j < trainParameters.ticksTrain; j++)
{
stockNNES.RunTick();
}
KeyValuePair <EvolutionalEntity <Action>, float> bestPerformerTrain = stockNNES.Performances.OrderBy(p => p.Value).Last();
trainStatistics.Add(new NNStockStatistics {
EvolutionalEntity = bestPerformerTrain.Key, Performance = bestPerformerTrain.Value, Generation = i + 1
});
trainAverage.Add(new NNStockStatistics {
EvolutionalEntity = null, Performance = GetAverage(stockNNES), Generation = i + 1
});
Dictionary <EvolutionalEntity <Action>, float> performance = new Dictionary <EvolutionalEntity <Action>, float>(stockNNES.Performances);
//test
stockNNES.Environment = new StockEnvironment(trainParameters.stockName, trainParameters.inputSize, trainParameters.ticksTest);
for (int j = 0; j < trainParameters.ticksTest; j++)
{
stockNNES.RunTick();
}
KeyValuePair <EvolutionalEntity <Action>, float> bestPerformerTest = stockNNES.Performances.OrderBy(p => p.Value).Last();
testStatistics.Add(new NNStockStatistics {
EvolutionalEntity = bestPerformerTest.Key, Performance = bestPerformerTest.Value, Generation = i + 1
});
testAverage.Add(new NNStockStatistics {
EvolutionalEntity = null, Performance = GetAverage(stockNNES), Generation = i + 1
});
GetAverage(stockNNES);
//reset performance
stockNNES.Performances = performance;
if (i != trainParameters.generations - 1)
{
stockNNES.CreateNextGeneration();
}
}
trainReturn.trainStatistics = trainStatistics;
trainReturn.testStatistics = testStatistics;
trainReturn.trainAverage = trainAverage;
trainReturn.testAverage = testAverage;
return(trainReturn);
}
public bool Retrain(TrainParameters train)
{
trainParameters = train;
return(_IsTrained = LoadTrainingData(Application.StartupPath + DIRECTORYDATABASE));
}
