Asia Technical Case Studies

// GET api/values
public IEnumerable<string> Get()
{
    // azure ml rre start
    // InvokeRequestResponseService().Wait();
    string result = HttpPostRequestResponseService();

    // azure table storage start
    // InsertEntity();

    // sql database insert
    // SqlWrite();

    return new string[] { result };
}

public static string HttpPostRequestResponseService()
{
    var request = (HttpWebRequest)WebRequest.Create(
        //"http://requestb.in/z2ewgtz2"
        "https://asiasoutheast.services.azureml.net/<API_ADDRESS>"
        );

    var postData = "{\"Inputs\":{\"input1\":{\"ColumnNames\":[\"idx\",\"Age\",\"NumPromotion\",\"idx\",\"AvgPlayMinDay\",\"90DaysItemPurchaseCount\",\"GameLevelRange\",\"Crystals\",\"PromotionPath\",\"Race\",\"Gender\",\"RegCode\",\"PurchaseNum\",\"LogonCountPerWeek\",\"Country\",\"ChurnYN\"],\"Values\":[[\"0\",\"0\",\"0\",\"0\",\"0\",\"0\",\"0\",\"0\",\"value\",\"value\",\"value\",\"0\",\"0\",\"0\",\"value\",\"value\"],[\"0\",\"0\",\"0\",\"0\",\"0\",\"0\",\"0\",\"0\",\"value\",\"value\",\"value\",\"0\",\"0\",\"0\",\"value\",\"value\"]]}},\"GlobalParameters\":{}}";
    var data = Encoding.UTF8.GetBytes(postData);

    request.Method = "POST";
    request.Headers[HttpRequestHeader.Authorization] =
        "<Bearer_API_KEY>";
    request.ContentType = "application/json; charset=utf-8";
    request.ContentLength = data.Length;

    using (var stream = request.GetRequestStream())
    {
        stream.Write(data, 0, data.Length);
    }

    HttpWebResponse response;
    try {
        response = (HttpWebResponse)request.GetResponse();
    }
    catch (Exception e)
    {
        return e.ToString();
    }

    var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

    return responseString;
}

public static void InsertEntity() 
{ 
    CloudStorageAccount storageAccount = CloudStorageAccount.Parse( 
       CloudConfigurationManager.GetSetting("StorageConnectionString")); 
    CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); 
    CloudTable table = tableClient.GetTableReference("GameLog"); 
    CustomerEntity customer1 = new CustomerEntity("test", "data"); 
	// add more code data here  
    TableOperation insertOperation = TableOperation.Insert(customer1); 
    // execute entity insert opertation  
    table.Execute(insertOperation); 
}

#r "Microsoft.WindowsAzure.Storage"

using System;
using System.Threading.Tasks;
using System.Net.Http;
using System.Net.Http.Headers;

using Microsoft.WindowsAzure.Storage;
using Microsoft.WindowsAzure.Storage.Auth;
using Microsoft.WindowsAzure.Storage.Blob;

public class AzureBlobDataReference
{
    // Storage connection string used for regular blobs. It has the following format:
    // DefaultEndpointsProtocol=https;AccountName=ACCOUNT_NAME;AccountKey=ACCOUNT_KEY
    // It's not used for shared access signature blobs.
    public string ConnectionString { get; set; }

    // Relative uri for the blob, used for regular blobs as well as shared access
    // signature blobs.
    public string RelativeLocation { get; set; }

    // Base url, only used for shared access signature blobs.
    public string BaseLocation { get; set; }

    // Shared access signature, only used for shared access signature blobs.
    public string SasBlobToken { get; set; }
}

public enum BatchScoreStatusCode
{
    NotStarted,
    Running,
    Failed,
    Cancelled,
    Finished
}

public class BatchScoreStatus
{
    // Status code for the batch scoring job
    public BatchScoreStatusCode StatusCode { get; set; }


    // Locations for the potential multiple batch scoring outputs
    public IDictionary<string, AzureBlobDataReference> Results { get; set; }

    // Error details, if any
    public string Details { get; set; }
}

public class BatchExecutionRequest
{

    public IDictionary<string, AzureBlobDataReference> Inputs { get; set; }
    public IDictionary<string, string> GlobalParameters { get; set; }

    // Locations for the potential multiple batch scoring outputs
    public IDictionary<string, AzureBlobDataReference> Outputs { get; set; }
}

static async Task WriteFailedResponse(HttpResponseMessage response, TraceWriter log)
{
    log.Info(string.Format("The request failed with status code: {0}", response.StatusCode));

    // Print the headers - they include the requert ID and the timestamp, which are useful for debugging the failure
    log.Info(response.Headers.ToString());

    string responseContent = await response.Content.ReadAsStringAsync();
    log.Info(responseContent);
}

static async Task RunBatch(TraceWriter log)
{
    string storageAccountName = "<ACCOUNT_NAME>";
    string storageAccountKey = "<ACCOUNT_KEY>";
    string storageConnectionString = string.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", storageAccountName, storageAccountKey);
    string storageContainerName = "input";
    string storageOutputContainerName = "output";

    using (HttpClient client = new HttpClient())
    {
        var request = new BatchExecutionRequest()
        {
            Inputs = new Dictionary<string, AzureBlobDataReference>()
            {
                {
                    "input1",
                    new AzureBlobDataReference()
                    {
                        ConnectionString = storageConnectionString,
                        RelativeLocation = string.Format("{0}/game_data_utf_8.csv", storageContainerName)
                    }
                },
            },

            Outputs = new Dictionary<string, AzureBlobDataReference>()
            {

                {
                    "output1",
                    new AzureBlobDataReference()
                    {
                        ConnectionString = storageConnectionString,
                        RelativeLocation = string.Format("/{0}/output1results.csv", storageOutputContainerName)
                    }
                },
            },
            GlobalParameters = new Dictionary<string, string>() { }
        };

        string apiKey = "<API_KEY>";
        client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);

        // WARNING: The 'await' statement below can result in a deadlock if you are calling this code from the UI thread of an ASP.Net application.
        // One way to address this would be to call ConfigureAwait(false) so that the execution does not attempt to resume on the original context.
        // For instance, replace code such as:
        //      result = await DoSomeTask()
        // with the following:
        //      result = await DoSomeTask().ConfigureAwait(false)

        log.Info("Submitting the job...");

        // submit the job
        string BaseUrl = "https://ussouthcentral.services.azureml.net/<BATCH_URL>/jobs";
        var response = await client.PostAsJsonAsync(BaseUrl + "?api-version=2.0", request);
        if (!response.IsSuccessStatusCode)
        {
            await WriteFailedResponse(response, log);
            return;
        }

        string jobId = await response.Content.ReadAsAsync<string>();
        log.Info(string.Format("Job ID: {0}", jobId));

        // start the job
        Console.WriteLine("Starting the job...");
        response = await client.PostAsync(BaseUrl + "/" + jobId + "/start?api-version=2.0", null);
        if (!response.IsSuccessStatusCode)
        {
            await WriteFailedResponse(response, log);
            return;
        }
    }
}

public static void Run(string myBlob, TraceWriter log)
{
    //log.Info($"C# Blob trigger function processed: {myBlob}");

    RunBatch(log).Wait();
}

#r "System.Data"

using System;
using System.Data.SqlClient;

public static void Run(string myBlob, TraceWriter log)
{
    log.Info("C# Blob trigger function processed");

    using (var connection = new SqlConnection(
        "Server=tcp:<SQL_SERVER>.database.windows.net,1433;Initial Catalog=<DBNAME>;Persist Security Info=False;User ID=<LOGON_NAME>;Password=<LOGON_PWD>;MultipleActiveResultSets=False;Encrypt=True;TrustServerCertificate=False;Connection Timeout=30;"
            ))  
    {
        connection.Open();

        using (connection)
        {
            SqlCommand cmd = new SqlCommand();

            cmd.Connection = connection;
            cmd.CommandText = "INSERT INTO batch(blob)   VALUES(@blob)";	// insert some data on Azure SQL Database
            cmd.Parameters.AddWithValue("@blob", myBlob);
            cmd.ExecuteNonQuery();
        }
        log.Info("Connected successfully.");
    }
}

################################### 
##### Logistic Regression Analytics ##### 
################################### 
#install.packages("glm2") 
library(glm2) 
# select 2 target category variables  
adj_iris <- iris 
adj_iris$Species <- as.character(adj_iris$Species) 
adj_iris <- subset(adj_iris, Species %in% c('versicolor', 'virginica')) 
adj_iris$Species <- as.factor(adj_iris$Species) 
set.seed(10) 
# train / test split 
ind <- sample(2, nrow(adj_iris), replace=TRUE, prob=c(0.7,0.3)) 
trainData <- adj_iris[ind==1, ] 
testData <- adj_iris[ind==2, ] 
# modeling 
formula <- Species ~ Sepal.Length + Sepal.Width + Petal.Length + Petal.Width 
iris_logit <- glm(formula, data=trainData, family=binomial()) 
# save modeling result as .rds  
flower_func_logit = 
function(sl, sw, pl, pw){ 
  testData <- data.frame(Sepal.Length=sl, Sepal.Width=sw,  
                         Petal.Length=pl, Petal.Width=pw) 
   
  logitpred_a <- predict(iris_logit, newdata=testData, type="response") 
  logitpred <- ifelse(logitpred_a>=0.5, "virginica", "versicolor") 
   
  logitpred 
} 
save(iris_logit, flower_func_logit, file = "c:/Users/hcs64648/Desktop/iris_logit.RData")

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Threading.Tasks; 
using RDotNet; 
namespace ConsoleApplication1 
{ 
    class Program 
    { 
        static void Main(string[] args) 
        { 
            REngine.SetEnvironmentVariables(); 
            REngine engine = REngine.GetInstance(); 
            engine.Initialize(); 
 
            engine.Evaluate("load('c:/Users/hcs64648/Desktop/iris_logit.RData')"); 
            //var iris_logit = engine.GetSymbol("iris_logit"); 
            //var flower_func_logit = engine.GetSymbol("flower_func_logit"); 
            var rv = engine.Evaluate("flower_func_logit(1,1,1,1)");  // prediction here 
            Console.WriteLine(rv.ToString()); 
            engine.Dispose(); 
        } 
    } 
}