DEVELOPMENT OF A SYSTEM FOR COLLECTION AND VISUALIZATION OF SPORT ACHIEVEMENTS DATA Текст научной статьи по специальности «Компьютерные и информационные науки»

TECHNICAL SCIENCE

Ibaa Mahdi Saleh_Al Hasan Master degree Yanka Kupala state universiry of Grodno faculty :- (engineering science)

DOI: 10.24412/2520-6990-2021-18105-20-33 DEVELOPMENT OF A SYSTEM FOR COLLECTION AND VISUALIZATION OF SPORT

ACHIEVEMENTS DATA

Abstract.

Aim of the research is to design and is to design and development of a system for collection and visualization of sport achievements data Existing solutions for athlete data analysis were investigated. The solutions and software tools were described and the research methodology was investigated, where the mathematical models used in data analysis were studied, describing and defining big data storage techniques and design models, as well as multidimensional data analysis tools using OLAP techniques. The necessary metrics, data market, and fact table are designed for the data warehouse. Dimensions and measurements of an OLAP cube are also designed. The main elements of the software system are described, by building graphical models in a Unified Design Language (UML), and finally the user interfaces are designed and Methods and tools for designing, developing and integrating client - relied on server systems. Object-oriented and structural methodology for the development of software systems. Algorithms for processing large amounts of data

Keywords:- UML, OLAP, SQL Server, information

Introduction

Huge information has become a climb in size and development in all business undertakings because of the boundless utilization of PCs and IT frameworks in these units in the entirety of their activities. Data stored in different information systems has grown and accumulated in various systems combine with the diversity of information and applications used with diversity of sources and their complexity.

This information is riches in itself, as well as being a wealth used to justify and bolster regulatory choices because the competitive advantages provided by the data can provide the decision-making process for the institutions if they are well analyzed and managed.

Consequently expanding effectiveness and gain-fulness and reducing waste by use analysis tools techniques and utilizing information examination apparatuses and systems.

Using business intelligence tools, where documentation and data storage is automated using effective tools for linguistic information, analysis and management of modern processing techniques are very important to help obtain the information needed to be used and respond immediately to changing economic conditions and future vision in all aspects of business and different levels of management.

The management of business in sports institutions is one of the strategic projects that are considered to be the main economic pillars of many countries and investment companies in the world.

Currently, a sufficient amount of information has been accumulated in the field of sports, which is related both to the data on athletes, their achievements, and to the data on the competitions and venues being held, and administrators, as well as customer data ... etc.

Therefore, it is urgent to develop a system to collect and visualize data on sports achievements, which will not only allow the collection of information about athletes and their results, but also provide extensive re-

search, processing and visualization of data automatically, calculating the various indicators, budgeting the most promising games and analyzing the plan factor.

Subject area description

The trends of adding technological touch on data storage and analysis systems are gaining momentum and are becoming increasingly important in the expectations of dispensing human resources used in the collection, compilation and analysis of large amounts of data, as well as the almost complete exclusion of human in the composition and analysis of statistical or analytical data. The management of sports institutions and clubs is one of the most important areas of long-awaited analytical data processing to store, analyze and visualize data on athletes, their achievements, competitions and places where it's held. Therefore, the main conceptual aspect of developing a system for collecting and visualizing data on sports achievements in sports institutions and clubs is above all, integrating and synthesizing data on various achievements and competitions, finding patterns in large amounts of data and analyzing trends in athletic achievements and athletes.

In addition, data processing, analysis and visualization will not only allow information about different aspects of athletes, their data and achievements, but also to search for the necessary combinations and find patterns in large amounts of data, as well as to make strategic decisions early and in the appropriate field. There is no doubt that the development of a compass to collect and visualize mathematical data in addition to the proper structure and implementation of programs in the system is relevant. Using the advanced system will allow you to quickly obtain the necessary analytical information related to athletes' data and achievements, as well as contribute to the development of an appropriate business management strategy in general.Executive managers, sports club investors and training staff are interested in information about athletes' achievements, information about competitions and places to be held, and information on forecasting sports that are also

promising. Decision support systems provide information as an opportunity to analyze and visualize mathematical achievements and analyze the plan factor. Data is accumulated in information systems and over time, the growth of data volume does not permit the analysis of information by standard means. The main concept that will allow the task group to be based on data storage technology is databases, data warehouse, decision support systems, OLAP technology and data mining methods. This will allow not only to load the transaction database but also to achieve high speed in creating accurate reports based on actual data to provide data accuracy.

Decision support systems are used in sports institutions to obtain information about competitions, their places, the achievements of athletes, the various sports exercises and their times, the identification of different types and the plan factor, to make predictions about promising sports. These systems allow you to create a wealth of data by integrating data from geographically distributed sources and analyzing and visualizing different patterns.

It should be noted that in the operational systems are stored and processing huge amounts of information. Over time, the growth of information data volume does not permit the analysis of information by standard means of operational systems. The basic concept underlying the proposed solution is the decision support system using data storage and integration from multiple

sources and OLAP technology. This will allow not only download the transaction database, but also to achieve high speed in creating accurate reports based on the actual data to provide detailed data. In addition, the advanced system will allow the visualization of different data in the form of graphs, graphs, decision trees, which will ensure easy understanding of information Development of the data warehouse In this work we will use a star schema as a repository model that is the main sample of the dimensional model. Contains a table of facts and a set of tables placed around smaller dimensions of the fact table. The fact of the data will change over time. The most relevant fact tables are digital and add-on for rare data repository access to single registration applications. They have access to hundreds, thousands and millions of simultaneous records and totals. The fact table is linked to all dimensional tables by one for many relationships. It includes measures that can be assembled in different ways [34-36]. The dimension table is configured for each entity. Facts table is configured for each entity transaction. The main table is a combination of keys and its related components. When the hierarchical relationships between the treatments of entities, the sub-entity inherits all dimensions (main features) of the entity origin. This allows you to "look down" at the transaction level. Figure 4.3 shows data Warehouse Logical Design are fact tables and dimensions.

^ TIME_ DIMENSION

Time Identifier integer <pk>

Day of the week varchar(50)

Day of the month varchar(50)

Month varchar(50)

Quarter varchar(50)

Year varchar(4)

Period varchar(50)

i

FK ACHIEVEM REFERENCE TIME Dl

COMPETITION DIMENSION

Competí tion Key

Competition Name

Specialization

Address

Level

Supervisor NumberAwards TotalAthletes StartDate End Date

integer

varchar(50)

varchar(25)

varchar(100)

varchar(25)

varchar(25)

numeric(10)

integer

date

date

SPORT TYPE

DIMENSION

<pk>

SportKev integer

SportName varchar{25)

Numbersub-Sport numeric(2)

NumberPlayg rounds numeric(2)

NumberPlayers numeric(10)

CategorySport varchar{25)

FK_ACHIEVEM_REF

ERENCE_SPORT_TY

s ACHIEVEMENTS _FACT

Time Identifier integer <fk4>

AthleteKey integer <fk5>

CompetitionKey integer <fk2>

Award Key integer <fk1>

SportKey integer <fk3>

Sum integer

Average integer

Count integer

FK ACHIEVEM REFERENCE AWARD D

ATHLETE_ DIMENSION

Athlete Kev inteqer <pk>

First Name varchar(10)

LastName varchar(10)

MiddleName varchar(10)

Data Birth date

Social Status char(10)

Sex varchar(10)

E-mail Address varchar{50)

Phone Number integer

Nationality varchar{25)

Civil No integer

Specialization varchar{25)

AthleticAffi Nation varchar{25)

FK ACHIEVEM REFERENCE ATHLETE

FK ACHIEVEM REFERENCE COMPETIT

^ AWARD _ DIMENSION

Award Key integer <pk>

Award Name varchar(25)

AwardType varchar(25)

Classification varchar(25)

Award Data times tamp

Level varchar(10)

Figure 1 - Shows the physical design data warehouse schema

A data warehouse is implemented in Microsoft SQL Server. It is designed to store the data of the following tables: (ATHLETE DIMENSION, SPORTS TYPE DIMENSION, TIME DIMENSION, COMPETITION DIMENSION, AWARD DIMENSION,ACHIEVEMENTS FACT). The code to implementing data warehouse schema in listing 4.2. implementing data warehouse schema.

1. Implementing Dimensions The code for created the ATHLETE DIMENSION CREATE TABLE dbo.Athlete (

AthleteKey NVARCHAR(10) NOT NULL,

FastName NVARCHAR(10) NULL,

LastName NVARCHAR(10) NULL,

MidlleName NVARCHAR(10) NULL,

DateBirth DATE NULL,

Sex NVARCHAR(7) NULL,

EmailAddress NVARCHAR(50) NULL,

CivilNo NVARCHAR(20) NULL,

Phonenumber NVARCHAR(20) NULL,

Nationality NVARCHAR(20) NULL,

Socialstatus NVARCHAR(10) NULL,

Affiliation NVARCHAR(25) NULL,

Specialization NVARCHAR(25) NULL,

CONSTRAINT PK_Athlete PRIMARY KEY (AthleteKey)

); GO

The code for creating the TIME DIMENSION

CREATE TABLE dbo.Time (

Time_Identifier INT NOT NULL,

DayOfTheWeek NVARCHAR(50) NULL,

DayOfTheWonth NVARCHAR(50) NULL

Month NVARCHAR(50) NULL

Quarte NVARCHAR(50) NULL

Year NVARCHAR(4) NULL

Period NVARCHAR(50) NULL

);

CONSTRAINT PK_Time PRIMARY KEY (Time_Identifier)

GO

The code for creating the SPORTS TYPE dimension

CREATE TABLE dbo.SPORTSTYPE (

Sportkey INT NOT NULL,

SportName NVARCHAR(25) NULL,

Numbersub_sport numeric(2) NULL,

NumberPlaygrounds numeric(2) NULL

NumberPlayers numeric(10) NULL

CategorySport NVARCHAR(25) NULL

CONSTRAINT PK_SPORTSTYPE PRIMARY KEY (Sportkey)

); GO

The code for creating the COMPETITION DIMENSION

CREATE TABLE dbo. COMPETITION (

CompetitionKey INT NOT NULL,

CompetitionName NVARCHAR(50) NULL,

Specialization NVARCHAR(25) NULL,

Address NVARCHAR(100) NULL,

Level NVARCHAR(25) NULL,

Supervisor NVARCHAR(25) NULL,

NumberAwards nvarchar(10) NULL,

TotalAthletes nvarchar(10) NULL,

StartDate Date NULL,

EndDate Date NULL,

«coyyomum-joutmail» #rnimm, 2021 / technical science

23

CONSTRAINT PK_COMPETITION PRIMARY KEY (CompetitionKey)

); GO

The code for creatingAWARD DIMENSION

CREATE TABLE dbo. AWARD (

AwardKey INT NOT NULL

AwardName NVARCHAR(25) NULL,

AwardType NVARCHAR(25) NULL,

AwardDate DATETIME NULL,

Classification NVARCHAR(25) NULL,

Level NVARCHAR(10) NULL,

CONSTRAINT PK_AWARD PRIMARY KEY(AwardKey) );

GO

1. Create the Fact table

The code for creating FACT ACHIEVEMENTS

CREATE TABLE dbo.FactAchievements (

AwardKey INT NOT NULL

CompetitionKey INT NOT NULL

Sportkey INT NOT NULL

Time_Identifier INT NOT NULL

AthleteKey INT NOT NULL

CONSTRAINT PK_ Fact Achievements PRIMARY KEY(FactAchievements)

); GO

The code for add foreign key constraints for relationships with all dimensions.

ALTER TABLE dbo. Achievements ADD CONSTRAINT

FK_ Achievements_ AWARD FOREIGN KEY(AwardKey) REFERENCES dbo. AWARD(AwardKey); ALTER TABLE dbo. Achievements ADD CONSTRAINT

FK_ Achievements _ Competition FOREIGN KEY(CompetitionKey) REFERENCES dbo. Competition (CompetitionKey); ALTER TABLE dbo. Achievements ADD CONSTRAINT

FK_ Achievements_ SportType FOREIGN KEY(Sportkey) REFERENCES dbo. SportType (Sportkey); ALTER TABLE dbo. Achievements ADD CONSTRAINT

FK_ Achievements_ ATHLETE FOREIGN KEY(AthleteKey) REFERENCES dbo. ATHLETE (AthleteKey); ALTER TABLE dbo. Achievements ADD CONSTRAINT

FK_ Achievements_ TIME FOREIGN KEY(Time_Identifier) REFERENCES dbo.TIME(Time_Identifier); Development of the OLAP cube and interactions between system modules

OLAP cubes are a convenient and fast way to access, view and analyze information. The user gets a natural and intuitive data model, organized in the form of multidimensional cubes. The axes of the multidimensional coordinate system are the main features of the analyzed business process. Time is used as one of the measurements. At intersections - measurements (dimensions) there are data characteristic of the process - measures (measures).

Figure 2- Example of hypercube data

The user who analyzes the information can break a cube in different directions, and receive a summary. There are two main types of variables in multidimensional database management systems.In a multidimensional model window, a number of special operations are applied to the data, forming a "slide", "rotate", grouping and details.

TIME DIMENSION2

^ ATHLETE_ _ DIMENSION2

AthleteKey integer <pk>

FirstName \archar(10)

Last Name \archar(10)

MiddleName \archar(10)

Data Birth date

SocialStatus char(10)

Sex \archar(10)

E-mail Address varchar(50)

PhoneNumber integer

Nationality varchar(25)

Civil No integer

Specialization varchar(25)

AthletioAffiliation varchar(25)

Tme Identifier

Day OfThe Week

DayOfTheWonth

Month

Quarter

Year

Period

integer

varchar(50)

varchar(50)

varchar(50)

varchar(50)

varchar{4)

varchar(50)

<pk>

AWARD_ . DIMENSION2

AwardKev integer <pk>

Award Name varchar(25)

AwardType \archar(25)

Award Date timestamp

Classification varchar(25)

Le\el \archar(10)

Figure 3- OLAP dimensions

Thanks to a multidimensional data model, it is possible to formulate complex questions, generate reports, obtain subsets of data, draw appropriate conclusions and make predictions based on large amounts of information.

I

Creating a Base

_4_

Create a Data Source t

Create a Data Source Veiw t

Create D im erisioris, Entities Member Property Objects

I

Create Cube Measure, Measuregroup Partition Objects

±

Cube Processing ( Process Type-Process Full )

Figure 4 -The sequence of steps to generate a cube programmatically

The code to development of the olap cube and interactions between system module, listing 4.3. Cube generation and interactions between system modules

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using Microsoft.AnalysisServices;

using System.Data.SqlClient;

using System.Data;

using System.Data.OleDb;

namespace OLAPCube {

class CubeIBAA {

static void Main(string[] args) {

BuildCube();

}

//Cube Generation

26_TECHNICAL SCIENCE / «CQLiyOMUM-JOUrMaiL» #18(101], 2021

private static void BuildCube()

{

try

{

Console.WriteLine("process started to Cube creation ");

Console.WriteLine("");

string strDBServerName = "LocalHost";

string strProviderName = "msolap";

string strFactTableName = "FACTACHIEVEMENTS";

string strDBName = " Sportclub ";

string strCubeDBName = "OLAPCIUBSDB";

string strCubeDataSourceName = "OLAPDS";

string strCubeDataSourceViewName = "OLAPDSView";

int intDimensionTableCount = 5;

string[,] strTableNamesAndKeys = {

{ "ATHLETE"," AthleteKey", "

FACTACHIEVEMENTS", " AthleteKey " },

{ " COMPETITION ", " CompetitionKey", "

FACTACHIEVEMENTS", " CompetitionKey" },

{ "TIME","TimeKey", " FACTACHIEVEMENTS",

"TimeKey" },

{ "AWARDS"," AwardKey", "

FACTACHIEVEMENTS", " AwardKey" },

{ " SPORTSTYPE"," Sportkey", "

FACTACHIEVEMENTS", " Sportkey" },

} ;

Server objServer = new Server(); Database objDatabase = new Database();

Relational DataSource objDataSource = new RelationalDataSource(); DataSourceView objDataSourceView = new DataSourceView(); DataSet objDataSet = new DataSet();

Dimension[] objDimensions = new Dimension[intDimensionTableCount]; //Connecting to the Analysis Services. objServer = (Server)ConnectAnalysisServices(strDBServerName, strProviderName);

//Creating a Database.

objDatabase = (Database)CreateDatabase(objServer, strCubeDBName); //Creating a DataSource.

objDataSource = (RelationalDataSource)CreateDataSource(objServer, objDatabase, strCubeDataSourceName, strDBServerName, strDBName); //Creating a DataSourceView.

objDataSet = (DataSet)GenerateDWSchema(strDBServerName, strDBName, strFactTableName, strTableNamesAndKeys, intDimensionTableCount);

objDataSourceView = (DataSourceView)CreateDataSourceView(objData-base, objDataSource, objDataSet, strCubeDataSourceViewName);

//Creating the Dimension, Attribute, Hierarchy, and MemberProperty

Objects.

objDimensions = (Dimension[])CreateDimension(objDatabase, objDataSourceView, strTableNamesAndKeys, intDimensionTableCount);

//Creating the Cube, MeasureGroup, Measure, and Partition Objects. CreateCube(objDatabase, objDataSourceView, objDataSource, objDi-mensions, strFactTableName, strTableNamesAndKeys, intDimensionTableCount); objDatabase.Process(ProcessType.ProcessFull); Console.WriteLine("The cube was successfully created.");

}

catch (Exception ex) {

Console.WriteLine("Error -> " + ex.Message);

}

Console.WriteLine("");

Console.WriteLine("Press any key to exit.");

Console.ReadLine();

}

//Connecting to the Analysis Services.

private static object ConnectAnalysisServices(string strDBServerName,

string strProviderName) {

try {

Console.WriteLine("Connecting to the Analysis Services ..."); Server objServer = new Server();

string strConnection = "Data Source=" + strDBServerName + ";Pro-vider=" + strProviderName + ";";

//Disconnect from current connection if it's currently connected, if (objServer.Connected) objServer.Disconnect();

else

objServer.Connect(strConnection); return objServer;

}

catch (Exception ex) {

Console.WriteLine("Error in Connecting to the Analysis Services. Error Message -> " + ex.Message);

return null;

}

}

//Creating a Database.

private static object CreateDatabase(Server objServer, string

strCubeDBName) {

try {

Console.WriteLine("Creating a Database .."); Database objDatabase = new Database(); //Add Database to the Analysis Services.

objDatabase objServer.Databases.Add(objServer.Databases.Get-NewName(strCubeDBName));

//Save Database to the Analysis Services.

objDatabase.Update();

return objDatabase;

}

catch (Exception ex) {

Console.WriteLine("Error in Creating a Database. Error Message ->

" + ex.Message);

return null;

}

}

//Creating a DataSource.

private static object CreateDataSource(Server objServer, Database objDatabase, string strCubeDataSourceName, string strDBServerName, string strDBName) {

try {

Console.WriteLine("Creating a DataSource ..."); RelationalDataSource objDataSource = new RelationalDataSource(); //Add Data Source to the Database.

28_TECHNICAL SCIENCE / «CQLiyOMUM-JOUrMaiL» #18(101], 2021

objDataSource = objDatabase.DataSources.Add(objServer.Data-bases.GetNewName(strCubeDataSourceName));

objDataSource.ConnectionString = "Provider=SQLOLEDB.1;Initial Cat-alog=AdventureWorksDW;Data Source=LocalHost;Integrated Security=True;";

objDataSource.ConnectionString = "Provider=SQLNCLI.1; Data Source=" + strDBServerName + "; Initial Catalog=" + strDBName + "; Integrated Secu-rity=SSPI;";

objDataSource.Update(); return objDataSource;

}

catch (Exception ex) {

Console.WriteLine("Error in Creating a DataSource. Error Message -> " + ex.Message);

return null;

}

}

//Creating a DataSourceView.

private static object GenerateDWSchema(string strDBServerName, string strDBName, string strFactTableName, string[,] strTableNamesAndKeys, int intDimen-

sionTableCount) {

try {

Console.WriteLine("Creating a DataSourceView ..."); //Create the connection string.

string conxString = "Data Source=" + strDBServerName + ";Initial Catalog=" + strDBName + ";Integrated Security=True;"; //Create the SqlConnection.

SqlConnection objConnection = new SqlConnection(conxString); DataSet objDataSet = new DataSet(); //Add FactTable in DataSet.

objDataSet = (DataSet)FillDataSet(objConnection, objDataSet, strFactTableName);

//Add table in DataSet and Relation between them.

for (int i = 0; i < intDimensionTableCount; i++) {

//Retrieve table's schema and assign the table's schema to the

DataSet.

//Add primary key to the schema according to the primary key

in the tables.

objDataSet = (DataSet)FillDataSet(objConnection, objDataSet, strTableNamesAndKeys[i, 0]);

objDataSet = (DataSet)AddDataTableRelation(objDataSet, strTableNamesAndKeys^, 0], strTableNamesAndKeys[i, 1], strTableNamesAndKeys[i, 2],

strTableNamesAndKeys[i, 3]); }

return objDataSet;

}

catch (Exception ex) {

Console.WriteLine("Error in Creating a DataSourceView - GenerateD-WSchema. Error Message -> " + ex.Message); return null;

}

}

// Fill the DataSet with DataTables.

private static object FillDataSet(SqlConnection objConnection, DataSet objDataSet, string strTableName) {

try {

string strCommand = "Select * from " + strTableName; SqlDataAdapter objEmpData = new SqlDataAdapter(strCommand, objCon-

nection);

objEmpData.MissingSchemaAction = MissingSchemaAction.AddWithKey; objEmpData.FillSchema(objDataSet, SchemaType.Source, strTable-

Name);

return objDataSet;

}

catch (Exception ex) {

Console.WriteLine("Error in Creating a DataSourceView - FillDa-taSet. Error Message -> " + ex.Message); return null;

}

}

// Add relations between DataTables of DataSet.

private static object AddDataTableRelation(DataSet objDataSet, string strParentTableName, string strParentTableKey, string strChildTableName, string

strChildTableKey) {

try {

objDataSet.Relations.Add(strChildTableName + "_" + strParentTable-Name + "_FK", objDataSet.Tables[strParentTableName].Columns[strParentTableKey], objDataSet.Tables[strChildTableName].Columns[strChildTableKey]);

return objDataSet;

}

catch (Exception ex) {

Console.WriteLine("Error in Creating a DataSourceView -AddDataTableRelation. Error Message -> " + ex.Message); return null;

}

}

// Creating a DataSourceView.

private static object CreateDataSourceView(Database objDatabase, Rela-tionalDataSource objDataSource, DataSet objDataSet, string strCubeData-

SourceViewName) {

try {

//Add Data Source View to the Database.

objDataSourceView = objDatabase.DataSourceViews.Add(objData-base.DataSourceViews.

GetNewName(strCubeDataSourceViewName)); objDataSourceView.DataSourcelD = objDataSource.ID; objDataSourceView.Schema = objDataSet; objDataSourceView.Update();

return objDataSourceView;

}

catch (Exception ex) {

Console.WriteLine("Error in Creating a DataSourceView -CreateData-SourceView. Error Message -> " + ex.Message); return null;

}

}

//Creating the Dimension, Attribute, Hierarchy, and MemberProperty Objects.

private static object[] CreateDimension(Database objDatabase, DataSourceView objDataSourceView, string[,] strTableNamesAndKeys, int intDimensionTa-

bleCount) {

try {

Console.WriteLine("Creating the Dimension, Attribute, Hierarchy, and MemberProperty Objects ...");

Dimension[] objDimensions = new Dimension[intDimensionTableCount];

for (int i = 0; i < intDimensionTableCount; i++) {

objDimensions[i] = (Dimension)GenerateDimension(objDatabase, objDataSourceView, strTableNamesAndKeys[i, 0], strTableNamesAndKeys[i, 1]); }

//Add Hierarchy and Level //Add Member Property

objProdKeyAttribute.AttributeRelationships.Add(objProdDescAttrib-

ute.ID);

objDimension.Update(); return objDimensions;

}

catch (Exception ex) {

Console.WriteLine("Error in Creating the Dimension, Attribute, Hierarchy, and MemberProperty Objects. Error Message -> " + ex.Message); return null;

}

}

//Generate single dimension.

private static object GenerateDimension(Database objDatabase, DataSourceView objDataSourceView, string strTableName, string strTableKeyName) {

try {

Dimension objDimension = new Dimension(); //Add Dimension to the Database

objDimension = objDatabase.Dimensions.Add(strTableName); objDimension.Source = new DataSourceViewBinding(objData-

SourceView.ID);

DimensionAttributeCollection objDimensionAttributesColl = objDi-mension.Attributes; //Add Dimension Attributes

DimensionAttribute objAttribute = objDimensionAttrib-utesColl.Add(strTableKeyName);

//Set Attribute usage and source

«шшшшшим-лшигмау» #мш, 2021 / technical science

31

objAttribute.Usage = AttributeUsage.Key; objAttribute.KeyColumns.Add(strTableName, strTableKeyName, OleDbType.Integer);

objDimension.Update();

return objDimension;

}

catch (Exception ex) {

Console.WriteLine("Error in Creating the Dimension, Attribute, Hierarchy, and MemberProperty Objects - GenerateDimension. Error Message -> " + ex.Message);

return null;

}

}

//Creating the Cube, MeasureGroup, Measure, and Partition Objects.

private static void CreateCube(Database objDatabase, DataSourceView ob-jDataSourceView, RelationalDataSource objDataSource, Dimension[] objDimensions, string strFactTableName, string[,] strTableNamesAndKeys, int intDimensionTable-Count)

{

try {

Console.WriteLine("Creating the Cube, MeasureGroup, Measure, and Partition Objects ...");

Cube objCube = new Cube(); Measure objAchievements = new Measure(); Measure objAward = new Measure(); MdxScript objTotal = new MdxScript(); String strScript;

Partition objPartition = new Partition(); Command objCommand = new Command();

//Add Cube to the Database and set Cube source to the Data Source

View

objCube = objDatabase.Cubes.Add("Cube model");

objCube.Source = new DataSourceViewBinding(objDataSourceView.ID); //Add Measure Group to the Cube

MeasureGroup objMeasureGroup = objCube.MeasureGroups.Add("Fac-

tAchievements");

MeasureGroup objMeasureGroup = objCube.MeasureGroups.Add(strFac-

tTableName);

//Add Measure to the Measure Group and set Measure source objAchievements = objMeasureGroup.Measures.Add("Total"); objA-chievements.Source = new DataItem(strFactTableName, " Achievements Total", OleDbType.Integer);

objAward = objMeasureGroup.Measures.Add("Numbers"); objA-ward.Source = new DataItem(strFactTableName, "Award Number", OleDbType.Integer);

//Calculated Member Definition //Add Calculated Member

for (int i = 0; i < intDimensionTableCount; i++) {

GenerateCube(objCube, objDimensions[i], objMeasureGroup, strFactTableName, strTableNamesAndKeys[i, 3]);

}

objPartition = objMeasureGroup.Partitions.Add(strFactTableName); objPartition.Source = new TableBinding(objDataSource.ID, "dbo", strFactTableName);

objPartition.ProcessingMode = ProcessingMode.Regular; objPartition.StorageMode = StorageMode.Molap; //Save Cube and all major objects to the Analysis Services objCube.Update(UpdateOptions.ExpandFull);

}

catch (Exception ex) {

Console.WriteLine("Error in Creating the Cube, MeasureGroup, Measure, and Partition Objects. Error Message -> " + ex.Message); }

}

// Generate cube.

private static void GenerateCube(Cube objCube, Dimension objDimension,

MeasureGroup objMeasureGroup, string strFactTableName, string strTableKey) {

try {

CubeDimension objCubeDim = new CubeDimension(); RegularMeasureGroupDimension objRegMGDim = new RegularMeasure-GroupDimension();

MeasureGroupAttribute objMGA = new MeasureGroupAttribute(); //Add Dimension to the Cube

objCubeDim = objCube.Dimensions.Add(objDimension.ID);

//Use Regular Relationship Between Dimension and FactTable Measure

Group

objRegMGDim = objMeasureGroup.Dimensions.Add(objCubeDim.ID); //Link TableKey in DimensionTable with TableKey in FactTable Measure Group

objMGA = objRegMGDim.Attributes.Add(objDimension.KeyAttribute.ID);

objMGA.Type = MeasureGroupAttributeType.Granularity; objMGA.KeyColumns.Add(strFactTableName, strTableKey, OleDbType.In-

teger);

}

catch (Exception ex) {

Console.WriteLine("Error in Creating the Cube, MeasureGroup, Measure, and Partition Objects - GenerateCube. Error Message -> " + ex.Message);

Conclousion

the general concept and physical structure of the system were presented and the stages of the system development were described. A general database of the system was developed, a Data Warehouse structure was built, and interactions between system modules and OLAP cube were developed. At the conclusion of the chapter, the capabilities of the development environment were explored; the collection and visualization of data on sports achievements were analyzed and tested.

References

1. How to Set Up MySQL on Google Compute Engine.2018.avalabale at https://cloud.google.com/so-lutions/setup-mysql.( December 21).

2. Cole, Jeremy (14 April 2011). Big and Small

Data at @Twitter. YouTube. Google. Retrieved 20 October 2011.

3. YouTube, Flickr, and Wikipedia to Share their Secrets of Success at the 2007. Santa Clara Convention Center in Santa Clara. avalibale at https://www.oreilly.com/pub/pr/1712.( April 23-26).

4. Berger A., Gorbach IStepanenko V. Microsoft SQL Server 2005 Analysis Services. OLAP and multidimensional data analysis. BHV. Melomed E., Scherb-inin V, 2007.p 864.

5. A. Berger, E. Melomed. Microsoft SQL Server 2008 Analysis Services. Pearson Education eBook Publish Date: January 21, 2009.p 1.36.

6. Mimer Information Technology, "Technical Overview", Mimer SQL Technical Description (PDF), archived from the original (PDF)on 9 August 2016.

7."IBM Pure Data System for Analytics, avalabale

at.

https://www.ibm.com/support/knowledgecenter/en/SS ULQD_7.0.3/com.ibm.nz.reln.doc/nzex_roadmap.htm l( 2013-07-31).

8. Reinsch, R. "Distributed database for SAA". IBM Systems Journal. (1988). 27 (3).p 362-389

9. This is Google's cache of https://www.webope-dia.com/TERM/J/Java.html. It is a snapshot of the page as it appeared on 3 Jun 2019

10. Normark, Kurt. Overview of the four main programming paradigms. Aalborg University, 9 May 2011. Retrieved 22 September 2012.

11."Java - Environment Setup", Tutorials Point avalabel at https://www.tutori-alspoint.com/java/java_environment_setup.htm.(17 November 2019).

12. Maklakov S.V. BPwin and EPwin. CASE-development tools for information systems. - M . DIALOG-MEPI, 2001. - 304 p.

UDC 004.8

Milkova Erika Gennadievna

Lecturer, Candidate of Economic Sciences Financial University under the Government of the Russian Federation

ARTIFICIAL INTELLIGENCE FOR MELANOMA DIAGNOSIS

Abstract.

Medicine, which focuses on the treatment of acute illnesses, is now more focused on chronic ailments. The main thing is to recognize disease before it manifests itself; our health and quality of life depend on the speed and quality of analysis. To solve the problem of melanoma diagnosis at an early stage, a system based on artificial intelligence has been developed that allows to automatically determine with at least 90% probability.

Keywords: AI, melanoma, network, skin, system, diagnosis.

Introduction

Artificial intelligence is an imitation of the machine "intelligent human behavior", which at the moment uses two AI technologies - expert systems and neural networks. In this article, we will consider AI implemented based on neural networks. Nowadays the question of training neural networks based on handwritten medical records is very much raised, then AI has saved many lives and reduced the cost of treatment. Due to the huge number of diseases, similar symptoms, and somewhere due to the inexperience of doctors, it is very difficult to detect an ailment at an early stage and prescribe the right treatment. This is precisely where artificial intelligence comes to the rescue, having access to databases with thousands and millions of case histories. Moreover, AI will be able to provide an individualized approach, taking into account information about the patient's genetic characteristics, movement patterns collected by his wearable devices, and previous medical history.

In the new millennium, there has been a boom in this type of AI, Machine Learning. It has become the main direction of AI development. Nowadays, these concepts have become almost identical and have become interchangeable. Machine learning generalizes the class of algorithms capable of improving their performance based on experience, human or its own, in solving applied problems. Such algorithms learn to make predictions by recognizing patterns hidden in data sets.

To train an algorithm we provide not only initial conditions (data) of the problems to be solved but also the correct answers to them. For example, we label the gallbladder in a photo/video of laparoscopic cholecys-tectomy, and the AI learns to recognize the gallbladder in the image. When learning without a teacher, we provide only the data itself without correct answers. The

algorithm, however, is expected to independently find a structure in the data that is a useful person. This could be, for example, optimal patient segmentation for a new disease or the identification of the bright red color of a certain texture (e.g., bleeding different from non-bleeding tissue). The third type of machine learning is reinforcement learning; this is a class of algorithms that independently interact with the external environment and extracts experience from that environment's response to its actions.

Learning with a teacher is the most common in applications. And one of the popular and effective tools for solving this problem in the last decade is artificial neural networks (Artificial Neural Networks). Neural networks are similar to the human nervous system in that data processing takes place in layers of simple computational systems — neurons, which receive input data (similar to dendrites in biological neurons), perform calculations, and transmit output data (similar to axons) to the next neuron. Input level neurons receive the data, while the hidden layer neurons layer (multiple hidden layers can be used) perform the calculations required to analyze the complex relationships in the data.

Materials and methods

Melanoma is a malignant tumor of predominantly cutaneous localization; it is the most common fatal skin disease, accounting for 1 to 4% of all cancer diagnoses. At the same time, skin cancer of all types accounts for <10% of oncological morbidity.

The high mortality rate in melanoma can be explained by untimely diagnosis, since in its early stages, as a rule, there are no painful symptoms. At the same time, surgical treatment gives good prognostic results just in case of early diagnosis of the disease. When melanoma is highly aggressive and biologically prone to early metastasis, delayed surgical treatment usually