private void PrepareStagingArea(Texture previewTexture)
{
this.m_StagingPath = Path.Combine(Path.Combine(DataLocation.localApplicationData, "WorkshopStagingArea"), Guid.NewGuid().ToString());
Directory.CreateDirectory(this.m_StagingPath);
//begin mod
this.m_PreviewPath = Path.Combine(this.m_StagingPath, "PreviewImage.png");
foreach (var previewImageFilename in PreviewImageFilenames)
{
var sourceFileName = Path.Combine(this.m_TargetFolder, previewImageFilename);
if (File.Exists(sourceFileName))
{
File.Copy(sourceFileName, m_PreviewPath);
break;
}
}
if (!File.Exists(m_PreviewPath))
{
var texture2D = UnityEngine.Object.Instantiate((Texture)m_DefaultModPreviewTexture) as Texture2D;
if (texture2D != null)
{
File.WriteAllBytes(m_PreviewPath, texture2D.EncodeToPNG());
}
}
//end mod
ReloadPreviewImage();
this.m_ContentPath = Path.Combine(this.m_StagingPath, "Content" + (object)Path.DirectorySeparatorChar);
Directory.CreateDirectory(this.m_ContentPath);
WorkshopHelper.DirectoryCopy(this.m_TargetFolder, this.m_ContentPath, true);
this.StartWatchingPath();
}
public void Train()
{
var modelPath = WorkshopHelper.GetModelPath(ModelFile);
var trainingData = WorkshopHelper.GetTrainingDataFile("packt", TrainingFile);
var trainingDataView = WorkshopHelper.LoadTrainingData <RestaurantFeedback>(Context, trainingData);
// Split sample data into training and test
var dataSplit = Context.Data.TrainTestSplit(trainingDataView, testFraction: 0.2);
var processPipeline = Context.Transforms.Text.FeaturizeText(
outputColumnName: "Features",
inputColumnName: nameof(RestaurantFeedback.Text));
var trainer = Context.BinaryClassification.Trainers.SdcaLogisticRegression(labelColumnName: nameof(RestaurantFeedback.Label),
featureColumnName: "Features")
.AppendCacheCheckpoint(Context);
var trainingPipeline = processPipeline.Append(trainer);
var trainedModel = trainingPipeline.Fit(dataSplit.TrainSet);
Context.Model.Save(trainedModel, dataSplit.TrainSet.Schema, modelPath);
var testSetTransform = trainedModel.Transform(dataSplit.TestSet);
var modelMetrics = Context.BinaryClassification.Evaluate(data: testSetTransform, labelColumnName: nameof(RestaurantFeedback.Label), nameof(RestaurantPrediction.Score));
Console.WriteLine($"Area Under Curve: {modelMetrics.AreaUnderRocCurve:P2}{Environment.NewLine}" +
$"Area Under Precision Recall Curve: {modelMetrics.AreaUnderPrecisionRecallCurve:P2}{Environment.NewLine}" +
$"Accuracy: {modelMetrics.Accuracy:P2}{Environment.NewLine}" +
$"F1Score: {modelMetrics.F1Score:P2}{Environment.NewLine}" +
$"Positive Recall: {modelMetrics.PositiveRecall:#.##}{Environment.NewLine}" +
$"Negative Recall: {modelMetrics.NegativeRecall:#.##}{Environment.NewLine}");
}
public void Train()
{
// Define paths and initial variables
var modelPath = WorkshopHelper.GetModelPath(ModelFile);
var trainingData = WorkshopHelper.GetTrainingDataFile("ms", TrainingFile);
var connectionString = $"Data Source=(LocalDB)\\MSSQLLocalDB;AttachDbFilename={trainingData};Integrated Security=True;Connect Timeout=30;";
// Load the data
var loader = Context.Data.CreateDatabaseLoader <BikeInput>();
var query = "SELECT RentalDate, CAST(Year as REAL) as Year, CAST(TotalRentals as REAL) as TotalRentals FROM Rentals";
var dbSource = new DatabaseSource(SqlClientFactory.Instance, connectionString, query);
var dataView = loader.Load(dbSource);
var firstYear = Context.Data.FilterRowsByColumn(dataView, "Year", upperBound: 1);
var secondYear = Context.Data.FilterRowsByColumn(dataView, "Year", upperBound: 2);
// Define analysis pipeline
var forecastPipeline = Context.Forecasting.ForecastBySsa(
outputColumnName: "ForecastedRentals",
inputColumnName: "TotalRentals",
windowSize: 7,
seriesLength: 30,
trainSize: 365,
horizon: 7,
confidenceLevel: 0.95f,
confidenceLowerBoundColumn: "LowerBoundRentals",
confidenceUpperBoundColumn: "UpperBoundRentals");
var forecaster = forecastPipeline.Fit(firstYear);
}
public void Train()
{
var modelPath = WorkshopHelper.GetModelPath(ModelFile);
var trainingData = WorkshopHelper.GetTrainingDataFile("packt", TrainingFile);
var trainingDataView = WorkshopHelper.LoadTrainingData <Email>(Context, trainingData, shuffle: true);
var dataProcessingPipeline = Context.Transforms.Conversion.MapValueToKey(inputColumnName: nameof(Email.Category), outputColumnName: "Label")
.Append(Context.Transforms.Text.FeaturizeText(inputColumnName: nameof(Email.Subject), outputColumnName: "SubjectFeaturized"))
.Append(Context.Transforms.Text.FeaturizeText(inputColumnName: nameof(Email.Body), outputColumnName: "BodyFeaturized"))
.Append(Context.Transforms.Text.FeaturizeText(inputColumnName: nameof(Email.Sender), outputColumnName: "SenderFeaturized"))
.Append(Context.Transforms.Concatenate("Features",
"SubjectFeaturized", "BodyFeaturized", "SenderFeaturized"))
.AppendCacheCheckpoint(Context);
var trainingPipeline = dataProcessingPipeline.Append(Context.MulticlassClassification.Trainers
.SdcaMaximumEntropy("Label", "Features"))
.Append(Context.Transforms.Conversion.MapKeyToValue("PredictedLabel"));
var testData = WorkshopHelper.GetTrainingDataFile("packt", "EmailTest.csv");
var testDataView = WorkshopHelper.LoadTrainingData <Email>(Context, testData);
var trainedModel = trainingPipeline.Fit(trainingDataView);
Context.Model.Save(trainedModel, trainingDataView.Schema, modelPath);
var modelMetrics = Context.MulticlassClassification.Evaluate(trainedModel.Transform(testDataView));
Console.WriteLine($"MicroAccuracy: {modelMetrics.MicroAccuracy:0.###}");
Console.WriteLine($"MacroAccuracy: {modelMetrics.MacroAccuracy:0.###}");
Console.WriteLine($"LogLoss: {modelMetrics.LogLoss:#.###}");
Console.WriteLine($"LogLossReduction: {modelMetrics.LogLossReduction:#.###}");
}
public Result PutWorkshop([FromBody] IEnumerable <Workshop> details)
{
if (details == null || !details.Any())
{
return(Result.GenError <Result>(Error.ParamError));
}
var markedDateTime = DateTime.Now;
foreach (var detail in details)
{
detail.MarkedDateTime = markedDateTime;
detail.Abbrev = detail.Abbrev ?? "";
detail.Remark = detail.Remark ?? "";
}
if (details.Any(x => x.Name.IsNullOrEmpty()))
{
if (details.Any(x => x.Id == 0))
{
return(Result.GenError <Result>(Error.WorkshopNotExist));
}
var ids = details.Select(x => x.Id);
var cnt = WorkshopHelper.Instance.GetCountByIds(ids);
if (cnt != details.Count())
{
return(Result.GenError <Result>(Error.WorkshopNotExist));
}
WorkshopHelper.Enable(details);
}
else
{
if (details.GroupBy(x => x.Name).Any(y => y.Count() > 1))
{
return(Result.GenError <Result>(Error.WorkshopDuplicate));
}
if (details.Any(x => !x.ValidShifts()))
{
return(Result.GenError <Result>(Error.WorkshopShiftsError));
}
var sames = details.Select(x => x.Name);
var ids = details.Select(x => x.Id);
if (WorkshopHelper.Instance.HaveSame(sames, ids))
{
return(Result.GenError <Result>(Error.WorkshopIsExist));
}
var cnt = WorkshopHelper.Instance.GetCountByIds(ids);
if (cnt != details.Count())
{
return(Result.GenError <Result>(Error.WorkshopNotExist));
}
WorkshopHelper.Instance.Update(details);
}
return(Result.GenError <Result>(Error.Success));
}
public DataResult GetWorkshop([FromQuery] int qId, bool menu)
{
var result = new DataResult();
result.datas.AddRange(menu
? WorkshopHelper.GetMenu(qId)
: WorkshopHelper.GetDetails(qId));
if (qId != 0 && !result.datas.Any())
{
result.errno = Error.WorkshopNotExist;
return(result);
}
return(result);
}
public DataResult GetAccount([FromQuery] int qId, bool menu, bool ws, bool all, string ids, string eIds)
{
var result = new DataResult();
if (ws)
{
if (qId == 0)
{
result.errno = Error.AccountNotExist;
return(result);
}
var acc = AccountInfoHelper.Instance.Get <AccountInfo>(qId);
if (acc == null)
{
result.errno = Error.AccountNotExist;
return(result);
}
if (acc.Id == 1 || acc.Belongs.Any())
{
result.datas.AddRange(WorkshopHelper.GetMenus(acc.Belongs));
}
return(result);
}
var idList = !ids.IsNullOrEmpty() ? ids.Split(",").Select(int.Parse) : new List <int>();
var eIdList = !eIds.IsNullOrEmpty() ? eIds.Split(",").Select(int.Parse) : new List <int>();
if (menu)
{
result.datas.AddRange(AccountInfoHelper.GetMenu(all, qId, idList, eIdList));
}
else
{
var data = AccountInfoHelper.GetAccountInfos(qId, all, idList, eIdList);
var wIds = data.SelectMany(x => x.Belongs);
var workshops = WorkshopHelper.Instance.GetByIds <Workshop>(wIds);
foreach (var d in data)
{
d.WorkShops = d.Belongs.Where(wId => workshops.Any(x => x.Id == wId)).Select(wId => workshops.First(x => x.Id == wId).Name).Join();
}
result.datas.AddRange(data);
}
if (qId != 0 && !result.datas.Any())
{
result.errno = Error.AccountNotExist;
return(result);
}
return(result);
}
public void InitSteamWorkshopTest()
{
MethodInfo method;
if (ParameterPrefix == "SE")
{
method = WorkshopHelper.ReflectInitSteamWorkshop();
}
else
{
method = M.WorkshopHelper.ReflectInitSteamWorkshop();
}
Assert.IsNotNull(method);
}
public void ItemPublisherMethodTest(string name)
{
MethodInfo method;
if (ParameterPrefix == "SE")
{
method = WorkshopHelper.ReflectSteamWorkshopItemPublisherMethod(name);
}
else
{
method = M.WorkshopHelper.ReflectSteamWorkshopItemPublisherMethod(name);
}
Assert.IsNotNull(method);
}
public void UpdatePublishedItemTest()
{
MethodInfo method;
if (ParameterPrefix == "SE")
{
method = WorkshopHelper.ReflectSteamWorkshopItemPublisherMethod("UpdatePublishedItem", BindingFlags.Instance | BindingFlags.NonPublic);
}
else
{
method = M.WorkshopHelper.ReflectSteamWorkshopItemPublisherMethod("UpdatePublishedItem", BindingFlags.Instance | BindingFlags.Public);
}
Assert.IsNotNull(method);
}
public void Predict()
{
var modelFile = WorkshopHelper.GetModelPath(ModelFile);
var mlModel = WorkshopHelper.GetModelData(Context, modelFile);
var predictionEng = Context.Model.CreatePredictionEngine <Email, EmailPrediction>(mlModel);
var csvPath = WorkshopHelper.GetPredictionDataFile(TrainingFile);
var emails = WorkshopHelper.GetCsvData <Email>(file: csvPath);
foreach (var email in emails)
{
var predictions = predictionEng.Predict(email);
Console.WriteLine(
$"Based on input json:{Environment.NewLine}" +
$"{TrainingFile}{Environment.NewLine}" +
$"The email is predicted to be a {predictions.Category}");
}
}
static void Predictor(string chap, string input)
{
switch (chap)
{
case Courses.PktLogReg:
var chap2 = new PktLogRegPredict(input);
chap2.Predict();
break;
case Courses.PktMultiClass:
var emailJson = WorkshopHelper.GetPredictionDataFile(input);
var pktMultiPredict = new PktMultiClassPredict(emailJson);
pktMultiPredict.Predict();
break;
default:
PrintTable();
break;
}
}
public static void AfterPrepareStagingArea(WorkshopAssetUploadPanel __instance)
{
var m_ContentPath = __instance.GetType().GetField("m_ContentPath", RedirectorUtils.allFlags).GetValue(__instance) as string;
var m_TargetAsset = __instance.GetType().GetField("m_TargetAsset", RedirectorUtils.allFlags).GetValue(__instance) as Package.Asset;
var rootAssetFolder = Path.GetDirectoryName(m_TargetAsset.package.packagePath);
LogUtils.DoErrorLog($"rootAssetFolder2: {rootAssetFolder}; ");
bool bundledAnyFile = false;
if (!(CommonProperties.AssetExtraFileNames is null))
{
foreach (string filename in CommonProperties.AssetExtraFileNames)
{
var targetFilename = Path.Combine(rootAssetFolder, filename);
if (File.Exists(targetFilename))
{
File.Copy(targetFilename, Path.Combine(m_ContentPath, filename));
bundledAnyFile = true;
}
}
}
if (!(CommonProperties.AssetExtraDirectoryNames is null))
{
foreach (string directory in CommonProperties.AssetExtraDirectoryNames)
{
var targetFolder = Path.Combine(rootAssetFolder, directory);
if (Directory.Exists(targetFolder))
{
WorkshopHelper.DirectoryCopy(targetFolder, Path.Combine(m_ContentPath, directory), true);
bundledAnyFile = true;
}
}
}
if (bundledAnyFile)
{
var tagsField = (__instance.GetType().GetField("m_Tags", RedirectorUtils.allFlags));
tagsField.SetValue(__instance, (tagsField.GetValue(__instance) as string[]).Union(new string[] { CommonProperties.ModName, $"K45 {CommonProperties.Acronym}" }).Distinct().ToArray());
}
}
private void PrepareStagingArea(string folder)
{
string path = Guid.NewGuid().ToString();
var stagingPath = Path.Combine(Path.Combine(DataLocation.localApplicationData, "WorkshopStagingArea"), path);
m_StagingPath.SetValue(workshopModUploadPanel, stagingPath);
Directory.CreateDirectory(stagingPath);
var previewPath = Path.Combine(stagingPath, "PreviewImage.png");
foreach (var previewImageFilename in previewImageFilenames)
{
if (File.Exists(Path.Combine(folder, previewImageFilename)))
{
File.Copy(Path.Combine(folder, previewImageFilename), previewPath);
break;
}
}
if (!File.Exists(previewPath))
{
var defaultTexture = m_DefaultModPreviewTexture.GetValue(workshopModUploadPanel);
File.WriteAllBytes(previewPath, (UnityEngine.Object.Instantiate((Texture)defaultTexture) as Texture2D).EncodeToPNG());
}
m_PreviewPath.SetValue(workshopModUploadPanel, previewPath);
reloadPreviewImage.Invoke(workshopModUploadPanel, null);
var contentPath = Path.Combine(stagingPath, "Content" + Path.DirectorySeparatorChar);
m_ContentPath.SetValue(workshopModUploadPanel, contentPath);
Directory.CreateDirectory(contentPath);
WorkshopHelper.DirectoryCopy(folder, contentPath, true);
startWatchingPath.Invoke(workshopModUploadPanel, null);
}
private void UpdateItem()
{
try
{
string text1 = this.m_Title.text;
string text2 = this.m_Desc.text;
string text3 = this.m_ChangeNote.text;
string[] files = Directory.GetFiles(this.m_ContentPath, "*.*", SearchOption.AllDirectories);
if (true)
{
try
{
DirectoryUtils.DeleteDirectory(Path.Combine(this.m_ContentPath, "Source"));
}
catch (DirectoryNotFoundException ex)
{
ex.HelpLink = string.Empty;
}
catch (Exception ex)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Failed to delete source for " + this.m_ContentPath + "\n" + ex.ToString());
}
}
WorkshopHelper.VerifyAndFinalizeFiles(files, this.m_PublishedFileId.ToString());
//begin mod
string version = BuildConfig.applicationVersion;
this.m_CurrentHandle = PlatformService.workshop.UpdateItem(this.m_PublishedFileId, text1, text2, text3, this.m_PreviewPath, this.m_ContentPath, new string[2] {
"Mod", $"{version}-compatible"
});
//end mod
}
catch (Exception ex)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, ex.GetType().ToString() + " " + ex.Message);
UIView.ForwardException((Exception) new StagingException("Workshop Staging Failed", ex));
}
}
public DataResult GetAccountWorkshop([FromQuery] int qId)
{
var result = new DataResult();
if (qId == 0)
{
result.errno = Error.AccountNotExist;
return(result);
}
var acc = AccountInfoHelper.Instance.Get <AccountInfo>(qId);
if (acc == null)
{
result.errno = Error.AccountNotExist;
return(result);
}
if (acc.Id == 1 || acc.Belongs.Any())
{
result.datas.AddRange(WorkshopHelper.GetMenus(acc.Belongs));
}
return(result);
}
public void Predict()
{
var modelFile = WorkshopHelper.GetModelPath(ModelFile);
var mlModel = WorkshopHelper.GetModelData(Context, modelFile);
var predictionEng = Context.Model.CreatePredictionEngine <RestaurantFeedback, RestaurantPrediction>(mlModel);
Console.WriteLine($"Write down random feedback.");
while (true)
{
var input = Terminal.ReadLine;
var predict = predictionEng.Predict(new RestaurantFeedback {
Text = input
});
if (input == "exit".ToLowerInvariant())
{
break;
}
Console.WriteLine($"Based on \"{input}\", the feedback is predicted to be:{Environment.NewLine}{(predict.Prediction ? "Negative" : "Positive")} at a {predict.Probability:P0} confidence");
}
}
public void ToSteamTest()
{
var method = WorkshopHelper.ReflectToSteam();
Assert.IsNotNull(method);
}
public void ModIoCreateRequestTest()
{
var method = WorkshopHelper.ReflectCreateRequest();
Assert.IsNotNull(method);
}
