public void Netgative()
{
var value = new SentimentValue(wordItem.Object, "Text", -0.5);
Assert.AreEqual(-0.5, value.DataValue.Value);
Assert.IsFalse(value.DataValue.IsPositive);
}
public void CreateGood()
{
var value = SentimentValue.CreateGood(wordItem.Object);
Assert.AreEqual(1, value.DataValue.Value);
Assert.IsTrue(value.DataValue.IsPositive);
}
public void Positive()
{
var value = new SentimentValue(wordItem.Object, "Text", 0.5);
Assert.AreEqual(0.5, value.DataValue.Value);
Assert.IsTrue(value.DataValue.IsPositive);
}
public void CalculateQuantMultiTest()
{
relationships.Setup(item => item.Inverted)
.Returns((IWordItem)null);
relationships.Setup(item => item.PriorQuants)
.Returns(
new List <IWordItem>
{
new TestWordItem("Word")
{
QuantValue = 10,
},
new TestWordItem("Word")
{
QuantValue = 2,
}
});
var value = SentimentValue.CreateGood(wordItem.Object);
var target = new SentimentCalculator(value);
var result = (double)target.InvokeMethod("CalculateQuant");
Assert.AreEqual(6, result);
}
public void CreateBad()
{
var value = SentimentValue.CreateBad(wordItem.Object);
Assert.AreEqual(-1, value.DataValue.Value);
Assert.IsFalse(value.DataValue.IsPositive);
}
public SentimentValue CheckSentiment(IWordItem word)
{
if (Context.DisableFeatureSentiment &&
word.IsFeature)
{
return(null);
}
if (Context.Lexicon != null)
{
SentimentValue sentiment = Context.Lexicon.MeasureSentiment(word);
if (sentiment != null ||
!Context.UseBuiltInSentiment)
{
return(sentiment);
}
var builtIn = inner.CheckSentiment(word);
if (builtIn != null)
{
// original max strength is 3 we move it save scale as custom and also make it 4 time less powerfull
return(new SentimentValue(word, builtIn.Span, builtIn.DataValue.Value / 3 * Context.Lexicon.AverageStrength / 4));
}
else
{
return(null);
}
}
return(inner.CheckSentiment(word));
}
private SentimentValue ResolveSentiment()
{
var sentimentValue = handler?.MeasureSentiment(Owner);
if (Owner.IsInvertor &&
!Owner.IsUsedInSentiment())
{
if (handler?.Context.DisableFeatureSentiment == true)
{
return(null);
}
// is something inverted, but unknown to us
if (sentimentValue != null)
{
return(sentimentValue);
}
return(SentimentValue.CreateInvertor(Owner));
}
if (sentimentValue == null)
{
return(null);
}
sentimentValue = new SentimentCalculator(sentimentValue).Calculate();
return(sentimentValue);
}
public void MeasureSentiment(string word, string pos, int sentiment)
{
Text.Words.IWordItem wordItem = ActualWordsHandler.InstanceSimple.WordFactory.CreateWord(word, pos);
SentimentValue measurment = sentimentData.MeasureSentiment(wordItem);
Assert.AreEqual(sentiment, measurment?.DataValue.Value ?? 0);
}
public Document ReparseDocument(IRatingAdjustment adjustment)
{
if (adjustment?.Review?.Document == null)
{
throw new System.ArgumentNullException(nameof(adjustment));
}
adjustment.CalculateRating();
var document = new Document();
document.DocumentTime = adjustment.Review.Document.DocumentTime;
document.Stars = adjustment.Review.Document.Stars;
document.Id = adjustment.Review.Document.Id;
document.Author = adjustment.Review.Document.Author;
if (adjustment.Rating != null)
{
document.Stars = adjustment.Rating.StarsRating;
}
if (adjustment.Review.Text == null)
{
document.Text = adjustment.Review.Text;
}
foreach (var sentence in adjustment.Review.Sentences)
{
if (string.IsNullOrWhiteSpace(sentence.Text))
{
continue;
}
var sentenceItem = new SentenceItem(sentence.Text);
document.Add(sentenceItem);
foreach (var wordItem in sentence.Occurrences)
{
var word = WordExFactory.Construct(wordItem);
word.IsStop = wordItem.IsStopWord;
word.Phrase = wordItem.Parent?.Text;
word.NormalizedEntity = wordItem.NormalizedEntity;
word.Value = wordItem.Relationship.Sentiment?.DataValue?.Value;
word.IsAspect = wordItem.IsFeature;
SentimentValue value = adjustment.GetSentiment(wordItem);
if (value != null)
{
word.CalculatedValue = value.DataValue.Value;
}
else if (word.Value != null)
{
word.CalculatedValue = 0;
}
sentenceItem.Add(word);
}
}
document.Text = adjustment.Review.Document.Text;
return(document);
}
public SentimentCalculator(SentimentValue value)
{
if (value is null)
{
throw new ArgumentNullException(nameof(value));
}
wordItem = value.Owner;
sentimentValue = value;
}
public void Adjust(string word, double weight, double sentiment)
{
var table = new Dictionary <string, double>();
table[word] = weight;
sentimentData = SentimentDataHolder.PopulateEmotionsData(table);
Text.Words.IWordItem wordItem = ActualWordsHandler.InstanceSimple.WordFactory.CreateWord(word, "NN");
SentimentValue measurement = sentimentData.MeasureSentiment(wordItem);
Assert.AreEqual(sentiment, measurement.DataValue.Value);
}
public SentimentValue MeasureSentiment(IWordItem word)
{
if (!EmotionsTable.TryGetWordValue(word, out var value))
{
return(MeasureLookupSentiment(word));
}
var sentiment = new SentimentValue(word, value.Word, new SentimentValueData(value.Data.Value));
return(sentiment);
}
public void GetDistanced()
{
var value = SentimentValue.CreateBad(wordItem.Object);
var distanced = value.GetDistanced(1);
Assert.AreEqual(-1, distanced.DataValue.Value);
distanced = value.GetDistanced(2);
Assert.AreEqual(-1, distanced.DataValue.Value);
distanced = value.GetDistanced(3);
Assert.AreEqual(-0.5, distanced.DataValue.Value);
distanced = value.GetDistanced(5);
Assert.AreEqual(-0.25, distanced.DataValue.Value);
}
public void SentimentCalculatorConstructorTest()
{
IWordItem invertor = new TestWordItem(String.Empty);
relationships.Setup(item => item.Inverted)
.Returns(invertor);
relationships.Setup(item => item.PriorQuants)
.Returns(new List <IWordItem>());
var value = SentimentValue.CreateGood(wordItem.Object);
var target = new SentimentCalculator(value);
Assert.AreEqual(wordItem.Object, target.GetField <IWordItem>("wordItem"));
Assert.AreEqual(value, target.GetField <SentimentValue>("sentimentValue"));
}
private SentimentValue MeasureLookupSentiment(IWordItem word)
{
if (word is IPhrase ||
!EmotionsLookup.TryGetWordValue(word, out var value))
{
return(null);
}
var isInverted = word.Text.EndsWith("free", StringComparison.OrdinalIgnoreCase) ||
word.Text.EndsWith("proof", StringComparison.OrdinalIgnoreCase) ||
word.Text.EndsWith("less", StringComparison.OrdinalIgnoreCase);
var invertingEnd = isInverted ? -1 : 1;
var sentiment = new SentimentValue(word, word.Text, new SentimentValueData(value.Value * invertingEnd));
return(sentiment);
}
public void CalculateInvertTest()
{
IWordItem invertor = new TestWordItem("Invert");
relationships.Setup(item => item.Inverted)
.Returns(invertor);
relationships.Setup(item => item.PriorQuants)
.Returns(new List <IWordItem>());
var value = SentimentValue.CreateGood(wordItem.Object);
var target = new SentimentCalculator(value);
var result = target.Calculate();
Assert.AreEqual(-1, result.DataValue.Value);
}
public SentimentValue Calculate()
{
var calculatedValue = sentimentValue.DataValue.Value;
if (wordItem.Relationship.Inverted != null)
{
calculatedValue = -calculatedValue;
}
var quantitifier = CalculateQuant();
calculatedValue = calculatedValue * quantitifier;
var value = new SentimentValue(
wordItem,
new SentimentValueData(calculatedValue, sentimentValue.DataValue.SentimentSource));
return(value);
}
protected void Add(SentimentValue sentiment)
{
if (calculatedSentiments.ContainsKey(sentiment.Owner))
{
return;
}
if (sentiment.Owner.Relationship.Inverted != null)
{
calculatedSentiments[sentiment.Owner.Relationship.Inverted] =
new SentimentValue(
sentiment.Owner.Relationship.Inverted,
new SentimentValueData(0, SentimentSource.AdjustedCanceled));
}
Rating.AddSentiment(sentiment.DataValue);
calculatedSentiments[sentiment.Owner] = sentiment;
}
public void CalculateSmallQuantTest()
{
relationships.Setup(item => item.Inverted)
.Returns((IWordItem)null);
relationships.Setup(item => item.PriorQuants)
.Returns(
new List <IWordItem>
{
new TestWordItem("Quant")
{
QuantValue = 0.5
}
});
var value = SentimentValue.CreateGood(wordItem.Object);
var target = new SentimentCalculator(value);
var result = target.Calculate();
Assert.AreEqual(0.5, result.DataValue.Value);
}
public SentimentValue CheckSentiment(IWordItem word)
{
if (Context.DisableFeatureSentiment &&
word.IsFeature)
{
return(null);
}
if (Context.Lexicon != null)
{
SentimentValue sentiment = Context.Lexicon.MeasureSentiment(word);
if (sentiment != null ||
!Context.UseBuiltInSentiment)
{
return(sentiment);
}
}
return(inner.CheckSentiment(word));
}
public void CalculateQuantInvertor()
{
var invertor = new TestWordItem(String.Empty);
relationships.Setup(item => item.Inverted)
.Returns(invertor);
relationships.Setup(item => item.PriorQuants)
.Returns(
new List <IWordItem>
{
new TestWordItem("Word")
{
QuantValue = 10,
}
});
var value = SentimentValue.CreateGood(wordItem.Object);
var target = new SentimentCalculator(value);
var result = (double)target.InvokeMethod("CalculateQuant");
Assert.AreEqual(10, result);
}
public Document ReparseDocument(IRatingAdjustment adjustment)
{
if (adjustment?.Review?.Document == null)
{
throw new ArgumentNullException(nameof(adjustment));
}
adjustment.CalculateRating();
var document = new Document();
document.DocumentTime = adjustment.Review.Document.DocumentTime;
document.Stars = adjustment.Review.Document.Stars;
document.Id = adjustment.Review.Document.Id;
document.Author = adjustment.Review.Document.Author;
if (adjustment.Rating != null)
{
document.Stars = adjustment.Rating.StarsRating;
}
bool buildText = false;
if (adjustment.Review.Text != null)
{
document.Text = adjustment.Review.Text;
buildText = true;
}
var vector = new SentimentVector();
foreach (var sentence in adjustment.Review.Sentences)
{
if (string.IsNullOrWhiteSpace(sentence.Text))
{
continue;
}
var sentenceItem = new SentenceItem(sentence.Text);
document.Add(sentenceItem, buildText);
foreach (var wordItem in sentence.Occurrences)
{
var word = WordExFactory.Construct(wordItem);
word.IsStop = wordItem.IsStopWord;
word.Phrase = wordItem.Parent?.Text;
word.NormalizedEntity = wordItem.NormalizedEntity;
word.Span = word.Text;
var sentiment = wordItem.Relationship.Sentiment?.DataValue;
if (sentiment != null)
{
word.Value = sentiment.Value;
word.Span = wordItem.Relationship.Sentiment.Span;
}
word.IsAspect = wordItem.IsFeature;
SentimentValue value = adjustment.GetSentiment(wordItem);
if (value != null)
{
word.CalculatedValue = value.DataValue.Value;
}
else if (word.Value != null)
{
word.CalculatedValue = 0;
}
if (adjustment.Review.Context.ExtractAttributes)
{
PopulateAttributes(vector, word, wordItem);
}
sentenceItem.Add(word);
}
}
document.Text = adjustment.Review.Document.Text;
if (adjustment.Review.Context.ExtractAttributes)
{
document.Attributes = vector.GetProbabilities().ToDictionary(item => item.Data, item => item.Probability.ToString());
}
return(document);
}
public void Setup()
{
sentence = new Mock <ISentence>();
parent = new Mock <IWordItemRelationships>();
sentencePart = new Mock <ISentencePart>();
owner = new Mock <IWordItem>();
child = new Mock <IWordItemRelationships>();
parent.Setup(item => item.Owner)
.Returns(owner.Object);
owner.Setup(item => item.WordIndex)
.Returns(5);
first = new Mock <IWordItem>();
second = new Mock <IWordItem>();
third = new Mock <IWordItem>();
sentence.Setup(item => item.Occurrences)
.Returns(
new[]
{
first.Object,
second.Object,
third.Object
});
sentencePart.Setup(item => item.Sentence)
.Returns(sentence.Object);
first.Setup(item => item.POS).Returns(POSTags.Instance.NN);
first.Setup(item => item.Text).Returns("1");
first.Setup(item => item.IsSentiment)
.Returns(true);
first.Setup(item => item.IsFeature)
.Returns(false);
first.Setup(item => item.WordIndex)
.Returns(1);
second.Setup(item => item.Text).Returns("2");
second.Setup(item => item.POS).Returns(POSTags.Instance.NN);
second.Setup(item => item.IsSentiment)
.Returns(false);
second.Setup(item => item.IsFeature)
.Returns(false);
second.Setup(item => item.WordIndex)
.Returns(3);
third.Setup(item => item.Text).Returns("3");
third.Setup(item => item.POS).Returns(POSTags.Instance.NN);
third.Setup(item => item.IsSentiment)
.Returns(true);
third.Setup(item => item.IsFeature)
.Returns(false);
third.Setup(item => item.WordIndex)
.Returns(10);
parent.Setup(item => item.Part)
.Returns(sentencePart.Object);
first.Setup(item => item.Relationship)
.Returns(child.Object);
second.Setup(item => item.Relationship)
.Returns(child.Object);
third.Setup(item => item.Relationship)
.Returns(child.Object);
child.SetupSequence(item => item.Sentiment)
.Returns(SentimentValue.CreateBad(owner.Object))
.Returns(SentimentValue.CreateBad(owner.Object))
.Returns(SentimentValue.CreateGood(owner.Object))
.Returns(SentimentValue.CreateGood(owner.Object));
child.Setup(item => item.PriorQuants)
.Returns(new List <IWordItem>());
}
public static bool IsSentiment(this IContextWordsHandler instance, IWordItem word)
{
SentimentValue sentiment = instance.MeasureSentiment(word);
return(sentiment != null);
}
