private async Task MessageReceivedAsync(SocketMessage message)
{
if (message.Author.Id == _client.CurrentUser.Id)
return;
string messageContent = message.Content;
messageContent = Utf8Encoder.GetString(Utf8Encoder.GetBytes(messageContent));
if (message.Author.Id.ToString() == ownerId)
{
if (messageContent == "trenuj")
{
await message.Channel.SendMessageAsync("Trenuje...");
AdvertDetector.Learn();
await message.Channel.SendMessageAsync("Wytrenowany");
AdvertDetector.Load();
return;
}
}
if (message.Channel.Id.ToString() == channelId)
{
if (!string.IsNullOrWhiteSpace(messageContent) && messageContent.Length > 3)
{
string msg = messageContent.Replace("\n", " ").Replace("\r", " ");
Messages[message.Id] = msg;
SentimentPrediction resultprediction = AdvertDetector.Predict(msg);
string text = $"{(resultprediction.Probability * 100).ToString("0.00")}%: {StringBuilderStrings(msg.Take(30))}...";
await message.Channel.SendMessageAsync(text);
}
}
}
private void sent_but_Click(object sender, RoutedEventArgs e)
{
SentimentPrediction resultprediction = SentimentAnalyzer.predict(sent_input.Text);
String txt = $"Text: {sent_input.Text} | Prediction: {(Convert.ToBoolean(resultprediction.Prediction) ? "Toxic" : "Non Toxic")} sentiment | Probability of being toxic: {resultprediction.Probability} ";
sent_output.Text += txt + Environment.NewLine;
}
public String analyzeMsg_withSentiment(string m)
{
String result = "";
int target_player = 0;
if (m.Contains("P1") && !m.Contains("P2"))
{
target_player = 1;
}
else if (m.Contains("P2") && !m.Contains("P1"))
{
target_player = 2;
}
if (target_player != 0)
{
SentimentPrediction resultprediction = SentimentAnalyzer.predict(m);
Boolean neg = Convert.ToBoolean(resultprediction.Prediction);
if (neg)
{
score_neg[0]++;
score_neg[target_player]++;
}
else
{
score_pos[0]++;
score_pos[target_player]++;
}
updateVariables();
result = $" P{target_player} {(neg ? "-" : "+")} c={resultprediction.Probability}";
}
return(result);
}
static void Main(string[] args)
{
string dataPath = "wikipedia-detox-250-line-data.tsv";
LearningPipeline pipeline = new LearningPipeline();
TextLoader testData = new TextLoader(dataPath).CreateFrom <SentimentData>(separator: '\t');
pipeline.Add(testData);
pipeline.Add(new TextFeaturizer("Features", "SentimentText"));
pipeline.Add(new FastTreeBinaryClassifier());
PredictionModel <SentimentData, SentimentPrediction> model = pipeline.Train <SentimentData, SentimentPrediction>();
Console.WriteLine(Environment.NewLine + Environment.NewLine);
while (true)
{
Console.WriteLine("Please enter some statement:" + Environment.NewLine);
// Positive: He is the best, and the article should say that.
// Negative: Please refrain from adding nonsense to Wikipedia.
var input = Console.ReadLine();
SentimentData data = new SentimentData
{
SentimentText = input
};
SentimentPrediction prediction = model.Predict(data);
string text = "Prediction: " + prediction.Sentiment + Environment.NewLine;
Console.WriteLine(text);
}
}
private bool OnGetPredictSentiment(string SentimentText)
{
SentimentData sampleData = new SentimentData()
{
SentimentText = SentimentText
};
SentimentPrediction prediction = _modelEngine.Predict(sampleData);
return(prediction.Prediction);
}
/// <summary>
/// This function predicts wheter a given string is positive or negative.
/// </summary>
/// <param name="sentence">The string to predict from.</param>
/// <returns>True if positive, flase if negative.</returns>
public (bool sentiment, double probablility, double score) CheckSingleSentiment(string sentence)
{
PredictionEngine <T1, SentimentPrediction> predictionFunction = mlEnv.Model.CreatePredictionEngine <T1, SentimentPrediction>(mlModel);
T1 sampleStatement = new T1 {
SentimentText = sentence
};
SentimentPrediction resultPrediction = predictionFunction.Predict(sampleStatement);
return(resultPrediction.Prediction, resultPrediction.Probability, resultPrediction.Score);
}
public ActionResult <SentimentPrediction> Post([FromBody] SentimentData data)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
SentimentPrediction predictedValue = PredictionEngine.Predict(data);
return(Ok(predictedValue));
}
public static string Clasify(string _text)
{
mlContext = new MLContext();
TrainTestData splitDataView = LoadData();
model = BuildAndTrainModel(splitDataView.TrainSet);
text = _text;
SentimentPrediction resultPrediction = UseModelWithSingleItem();
return(Convert.ToBoolean(resultPrediction.Prediction) ? "Positive" : "Negative");
}
public ActionResult <SentimentPrediction> Post([FromBody] SentimentData data)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
SentimentPrediction predictedValue = PredictionEnginePool.Predict(modelName: ConfigurationManager.AppSettings.Get("modelName"), example: data);
return(Ok(predictedValue));
}
public ActionResult <string> Post([FromBody] SentimentData input)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
SentimentPrediction prediction = _predictionEnginePool.Predict(input);
string sentiment = Convert.ToBoolean(prediction.Prediction) ? "Positive" : "Negative";
return(Ok(sentiment));
}
public ActionResult <string> PredictSentiment([FromQuery] string sentimentText)
{
SentimentData sampleData = new SentimentData()
{
SentimentText = sentimentText
};
//Predict sentiment
SentimentPrediction prediction = _predictionEnginePool.Predict(sampleData);
bool isPositive = prediction.Sentiment;
float probability = CalculatePercentage(prediction.Score);
string retVal = $"Prediction: Postive?: '{isPositive.ToString()}' with {probability.ToString()}% probability of toxicity for the text '{sentimentText}'";
return(retVal);
}
public static void TestSinglePrediction(MLContext mlContext)
{
SentimentIssue sampleStatement = new SentimentIssue {
Text = "This is a very rude movie"
};
ITransformer trainedModel = mlContext.Model.Load(ModelPath, out DataViewSchema modelInputSchema);
// Create prediction engine related to the loaded trained model
PredictionEngine <SentimentIssue, SentimentPrediction> predictionEngine = mlContext.Model.CreatePredictionEngine <SentimentIssue, SentimentPrediction>(trainedModel);
//Score
SentimentPrediction resultPrediction = predictionEngine.Predict(sampleStatement);
Console.WriteLine($"=============== Single Prediction ===============");
Console.WriteLine($"Text: {sampleStatement.Text} | Prediction: {(Convert.ToBoolean(resultPrediction.Prediction) ? "Toxic" : "Non Toxic")} sentiment | Probability of being toxic: {resultPrediction.Probability} ");
Console.WriteLine($"==================================================");
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
//Parse HTTP Request Body
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
SentimentData data = JsonConvert.DeserializeObject <SentimentData>(requestBody);
//Make Prediction
SentimentPrediction prediction = _predictionEnginePool.Predict(data);
//Convert prediction to string
int sentiment = Convert.ToBoolean(prediction.Prediction) ? 1 : 0;
//Return Prediction
return((ActionResult) new OkObjectResult(sentiment));
}
public static SentimentPrediction Predict(SentimentData input)
{
// Create new MLContext
MLContext mlContext = new MLContext();
// Load model & create prediction engine
ITransformer mlModel = mlContext.Model.Load(
MLModelBuilder.GetAbsolutePath(Constants.ModelFilePath),
out var modelInputSchema);
System.Console.WriteLine(modelInputSchema);
var predEngine = mlContext.Model
.CreatePredictionEngine <SentimentData, SentimentPrediction>(mlModel);
// Use model to make prediction on input data
SentimentPrediction result = predEngine.Predict(input);
return(result);
}
public void Track(SentimentPrediction output, SentimentIssue input, ILogger logger)
{
try
{
string sentimentText = input.SentimentText;
var props = new Dictionary <string, string>
{
{ "model_uri", _modelUri?.ToString() },
{ "prediction_response", output.Prediction ? "Positive" : "Negative" },
{ "prediction_text", sentimentText },
};
_telemetryClient.TrackMetric("Prediction.Probability", output.Probability, props);
_telemetryClient.TrackMetric("Prediction.Score", output.Score, props);
}
catch (Exception ex)
{
// avoid fail prediction due to telemetry record saving issues
logger?.LogError(ex, nameof(Track));
}
}
public ActionResult <float> PostMultiple([FromBody] ICollection <SentimentData> texts)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
float probabilityPositive = 0;
float probabilityNegative = 0;
int countPositive = 0;
int countNegative = 0;
foreach (SentimentData data in texts)
{
SentimentPrediction predictedValue = PredictionEnginePool.Predict(modelName: ConfigurationManager.AppSettings.Get("modelName"), example: data);
if (predictedValue.Sentiment == true)
{
probabilityPositive += predictedValue.Probability;
countPositive++;
}
else
{
probabilityNegative += predictedValue.Probability;
countNegative++;
}
}
if (probabilityNegative < probabilityPositive)
{
return(Ok(new Sentiment(true, probabilityPositive / countPositive)));
}
else
{
return(Ok(new Sentiment(true, probabilityNegative / countNegative)));
}
}
public ActionResult <float> PostMultiple([FromBody] ICollection <SentimentData> texts)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
float probabilityPositive = 0;
float probabilityNegative = 0;
int countPositive = 0;
int countNegative = 0;
foreach (SentimentData data in texts)
{
SentimentPrediction predictedValue = PredictionEngine.Predict(data);
if (predictedValue.Prediction == true)
{
probabilityPositive += predictedValue.Probability;
countPositive++;
}
else
{
probabilityNegative += predictedValue.Probability;
countNegative++;
}
}
if (probabilityPositive >= probabilityNegative)
{
return(Ok(new Sentiment(true, probabilityPositive / countPositive)));
}
else
{
return(Ok(new Sentiment(false, probabilityNegative / countNegative)));
}
}
public static PredictionModel <SentimentData, SentimentPrediction> TrainAndPredict()
{
string pathCurrent = System.IO.Directory.GetCurrentDirectory();
var pipeline = new LearningPipeline();
pipeline.Add(new TextLoader <SentimentData>(_dataPath, useHeader: false, separator: "tab"));
pipeline.Add(new TextFeaturizer("Features", "SentimentText"));
pipeline.Add(new FastTreeBinaryClassifier()
{
NumLeaves = 5, NumTrees = 5, MinDocumentsInLeafs = 2
});
PredictionModel <SentimentData, SentimentPrediction> model = null;
try
{
model = pipeline.Train <SentimentData, SentimentPrediction>();
IEnumerable <SentimentData> sentiments = new[]
{
new SentimentData
{
SentimentText = "Contoso's 11 is a wonderful experience",
Sentiment = 0
},
new SentimentData
{
SentimentText = "The acting in this movie is very bad",
Sentiment = 0
},
new SentimentData
{
SentimentText = "Joe versus the Volcano Coffee Company is a great film.",
Sentiment = 0
},
new SentimentData
{
SentimentText = "horrible.",
Sentiment = 0
},
new SentimentData
{
SentimentText = "oh my godness. wonderful.",
Sentiment = 0
},
new SentimentData
{
SentimentText = "Contoso's 11 is not an ordinary expirence. just fine.",
Sentiment = 0
},
new SentimentData
{
SentimentText = "It's based on an personal condition.",
Sentiment = 0
}
};
IEnumerable <SentimentPrediction> predictions = model.Predict(sentiments);
var sentimentsAndPredictions = sentiments.Zip(predictions, (sentiment, prediction) => (sentiment, prediction));
Console.WriteLine();
Console.WriteLine("Result Sentiment Predictions >>>>>>>>>>>>>>>>>>");
Console.WriteLine("---------------------");
foreach ((SentimentData, SentimentPrediction)item in sentimentsAndPredictions)
{
SentimentData sentiment = item.Item1;
SentimentPrediction prediction = item.Item2;
Console.WriteLine($"Sentiment: {sentiment.SentimentText} | Prediction: {(prediction.Sentiment ? "Positive" : "Negative")}");
}
Console.WriteLine();
}
catch (Exception e)
{
Console.WriteLine("error:" + e.Message);
}
return(model);
}
static void Main(string[] args)
{
try
{
// Create MLContext
MLContext mlContext = new MLContext();
// Load Trained Model
DataViewSchema predictionPipelineSchema;
ITransformer predictionPipeline = mlContext.Model.Load("../../../MLModels/SentimentModel.zip", out predictionPipelineSchema);
// Create PredictionEngines
PredictionEngine <SentimentIssue, SentimentPrediction> predictionEngine = mlContext.Model.CreatePredictionEngine <SentimentIssue, SentimentPrediction>(predictionPipeline);
// Input Data (single)
SentimentIssue inputData = new SentimentIssue
{
Text = "I love this movie!"
};
// Get Prediction
SentimentPrediction prediction = predictionEngine.Predict(inputData);
Console.WriteLine($"=============== Single Prediction ===============");
Console.WriteLine($"Text: {inputData.Text} | Prediction: {(Convert.ToBoolean(prediction.Prediction) ? "Toxic" : "Non Toxic")} sentiment | Probability of being toxic: {prediction.Probability} ");
Console.WriteLine($"================End of Process.Hit any key to exit==================================");
// input data multiple
SentimentIssue[] inputArray = new SentimentIssue[]
{
new SentimentIssue
{
Text = "I love this movie!"
},
new SentimentIssue
{
Text = "F*****g good!"
},
};
//Load Data
IDataView data = mlContext.Data.LoadFromEnumerable <SentimentIssue>(inputArray);
// Predicted Data
IDataView predictions = predictionPipeline.Transform(data);
// Create an IEnumerable of prediction objects from IDataView
IEnumerable <SentimentPrediction> dataEnumerable =
mlContext.Data.CreateEnumerable <SentimentPrediction>(predictions, reuseRowObject: true);
// Iterate over each row
for (int i = 0; i < inputArray.Length; i++)
{
string input = inputArray[i].Text;
SentimentPrediction item = dataEnumerable.ElementAt(i);
// display
Console.WriteLine($"Text: {input} | Prediction: {(Convert.ToBoolean(item.Prediction) ? "Toxic" : "Non Toxic")} sentiment | Probability of being toxic: {item.Probability} ");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
Console.ReadLine();
}
private (string text, bool sentiment) BuildPredictionResult(SentimentPrediction prediction, ISentimentRequest request)
{
return(text : request.SentimentText, sentiment : prediction.Sentiment);
}
public JsonResult BuildJsonPredictionResult(SentimentPrediction prediction, ISentimentRequest request)
{
return(new JsonResult(BuildPredictionResult(prediction, request)));
}
