C# Dataset类代码示例

 public virtual void Test(Dataset data)
 {
     for (int i = 0; i < data.input.Count; ++i)
     {
         Console.WriteLine("{0} -> {1},  net = {2}", data.input[i].Print(), data.output[i].Print(), Predict(data.input[i]).Print());
     }
 }

    public void SupportVectorMachinePerformanceTest() {
      ex = null;

      var cv = new CrossValidation();
      cv.Algorithm = new SupportVectorRegression();
      var rand = new HeuristicLab.Random.MersenneTwister();
      double[,] data = GenerateData(1000, rand);
      List<string> variables = new List<string>() { "x1", "x2", "x3", "x4", "x5", "x6", "x7", "x8", "x9", "x10", "y" };
      Dataset ds = new Dataset(variables, data);
      cv.Problem.ProblemDataParameter.ActualValue = new RegressionProblemData(ds, variables.Take(10), variables.Last());
      cv.Folds.Value = 5;
      cv.SamplesStart.Value = 0;
      cv.SamplesEnd.Value = 999;

      cv.ExceptionOccurred += new EventHandler<EventArgs<Exception>>(cv_ExceptionOccurred);
      cv.Stopped += new EventHandler(cv_Stopped);

      cv.Prepare();
      cv.Start();
      trigger.WaitOne();
      if (ex != null) throw ex;

      TestContext.WriteLine("Runtime: {0}", cv.ExecutionTime.ToString());

    }

        public void TestMissingValues()
        {
            var contact = new Contact("Jim", "Does", "[email protected]", "Lollipops", "837773");
            var dataSet = new Dataset(new Site(4, "New Site", "Tim Jones", contact, contact, new GPSCoords(0, 0, "argis")));

            var sensor = new Sensor("Dummy Sensor", "Does stuff", 10, 0, "C", 5, dataSet);

            sensor.AddState(new SensorState(sensor, DateTime.Now));
            sensor.CurrentState.Values.Add(new DateTime(1990, 5, 1, 4, 0, 0), 15);
            sensor.CurrentState.Values.Add(new DateTime(1990, 5, 1, 5, 0, 0), 15);
            sensor.CurrentState.Values.Add(new DateTime(1991, 8, 2, 0, 0, 0), 15);

            dataSet.AddSensor(sensor);

            dataSet.DataInterval = 60;

            dataSet.HighestYearLoaded = 1;

            Assert.AreEqual(60, dataSet.DataInterval);

            var missingValues = missingValuesDetector.GetDetectedValues(sensor);

            for (var i = new DateTime(1990, 5, 1, 6, 0, 0); i < new DateTime(1991, 8, 2, 0, 0, 0); i = i.AddHours(1))
            {
                Assert.Contains(new ErroneousValue(i, missingValuesDetector, sensor), missingValues);
            }
        }

 public LegendItemBlockContainer(Arrangement arrangement, Dataset dataset, IComparable seriesKey)
   : base(arrangement)
 {
   LegendItemBlockContainer itemBlockContainer = this;
   this.dataset = dataset;
   this.seriesKey = seriesKey;
 }

    public override ITimeSeriesPrognosisProblemData ImportData(string path) {
      TableFileParser csvFileParser = new TableFileParser();
      csvFileParser.Parse(path, csvFileParser.AreColumnNamesInFirstLine(path));

      Dataset dataset = new Dataset(csvFileParser.VariableNames, csvFileParser.Values);
      string targetVar = csvFileParser.VariableNames.Last();

      IEnumerable<string> allowedInputVars = dataset.DoubleVariables.Where(x => !x.Equals(targetVar));

      ITimeSeriesPrognosisProblemData timeSeriesPrognosisData = new TimeSeriesPrognosisProblemData(dataset, allowedInputVars, targetVar);

      int trainingPartEnd = csvFileParser.Rows * 2 / 3;
      timeSeriesPrognosisData.TrainingPartition.Start = 0;
      timeSeriesPrognosisData.TrainingPartition.End = trainingPartEnd;
      timeSeriesPrognosisData.TestPartition.Start = trainingPartEnd;
      timeSeriesPrognosisData.TestPartition.End = csvFileParser.Rows;

      int pos = path.LastIndexOf('\\');
      if (pos < 0)
        timeSeriesPrognosisData.Name = path;
      else {
        pos++;
        timeSeriesPrognosisData.Name = path.Substring(pos, path.Length - pos);
      }
      return timeSeriesPrognosisData;
    }

        private void bTrainLines_Click(object sender, EventArgs e)
        {
            data = PragmaLearn.Exampels.Datasets.Lines.Create(100000);
            var hidden = data.GetInputDimension();
            if (network.GetInputs() != data.GetInputDimension() || network.GetOutputs() != data.GetOutputDimension())
                network.Init(data.GetInputDimension(), hidden, hidden, data.GetOutputDimension());

            network.learningRate = 0.0001f;
            network.lambda = 0.0f;

            Task.Run(() =>
            {
                running = true;

                int t = 0;
                while (running)
                {
                    t++;
                    // network.Train(data);

                    var batch = genMiniBatch(100);
                    network.TrainMiniBatch(data, batch);

                    Console.WriteLine("LEARNING RATE: " + network.learningRate);
                    //if (network.learningRate > 0.0001)
                    //    network.learningRate *= 0.9998;
                    if (t % 10 == 0)
                    {
                        this.Invoke(test);

                    }

                }
            });
        }

        public PlatformDb(IDbContext context)
        {
            #region Preconditions

            if (context == null)
                throw new ArgumentNullException(nameof(context));

            #endregion

            this.context = context;
            
            Apps              = new Dataset<App>(context);
            AppInstances      = new Dataset<AppInstance>(context);
            AppReleases       = new Dataset<AppRelease>(context);
            AppEvents         = new Dataset<AppEvent>(context);
            AppErrors         = new Dataset<AppError>(context);

            // Frontends
            Frontends         = new Dataset<Frontend>(context);
            FrontendBranches  = new Dataset<FrontendBranch>(context);
            FrontendReleases  = new Dataset<FrontendRelease>(context);

            // Networks
            Networks          = new Dataset<Network>(context);
            NetworkInterfaces = new Dataset<NetworkInterfaceInfo>(context);

            Hosts             = new Dataset<Host>(context);
            Volumes           = new Dataset<VolumeInfo>(context);
            Images            = new Dataset<Image>(context);
        }

	protected Visualization createVisualization(Dataset dataset, Transform parent) { 
		
		GameObject go = new GameObject();
		//string folderName = new DirectoryInfo(rootFolder).Name;
		Visualization v = go.AddComponent<Visualization>();		
		go.name = dataset.csvMetadataFile.name;			
		go.transform.parent = parent;	
		
		AutographerParser parser = go.AddComponent<AutographerParser>();
		//parser.allowInterp = this.GetComponent<AutographerParser>().allowInterp;
		//parser.imageResolution = this.GetComponent<AutographerParser>().imageResolution;		
		
		v.projectName = dataset.csvMetadataFile.name;
		v.csvMetadataFile = dataset.csvMetadataFile;
		v.imageDirectory = dataset.imageDirectory;
		v.imageExtension = dataset.imageExtension;
		//v.tb = this;
		v.targetMetadataParser = v.GetComponent<MetadataParser>();
		//v.pather = this.pather;
		//v.DoubleSidedMesh = this.DoubleSidedMesh;
		//v.quadTemplate = this.quadTemplate;
		v.quadTemplates = dataset.quadTemplates;
		v.tvisLayout = this.tvisLayout;
		v.usePhotos = this.usePhotos;
		//v.transform.parent = this.sceneParent;
		return v;
	}

    public override IRegressionProblemData ImportData(string path) {
      TableFileParser csvFileParser = new TableFileParser();
      csvFileParser.Parse(path, csvFileParser.AreColumnNamesInFirstLine(path));

      Dataset dataset = new Dataset(csvFileParser.VariableNames, csvFileParser.Values);
      string targetVar = dataset.DoubleVariables.Last();

      // turn off input variables that are constant in the training partition
      var allowedInputVars = new List<string>();
      var trainingIndizes = Enumerable.Range(0, (csvFileParser.Rows * 2) / 3);
      if (trainingIndizes.Count() >= 2) {
        foreach (var variableName in dataset.DoubleVariables) {
          if (dataset.GetDoubleValues(variableName, trainingIndizes).Range() > 0 &&
            variableName != targetVar)
            allowedInputVars.Add(variableName);
        }
      } else {
        allowedInputVars.AddRange(dataset.DoubleVariables.Where(x => !x.Equals(targetVar)));
      }

      IRegressionProblemData regressionData = new RegressionProblemData(dataset, allowedInputVars, targetVar);

      var trainingPartEnd = trainingIndizes.Last();
      regressionData.TrainingPartition.Start = trainingIndizes.First();
      regressionData.TrainingPartition.End = trainingPartEnd;
      regressionData.TestPartition.Start = trainingPartEnd;
      regressionData.TestPartition.End = csvFileParser.Rows;

      regressionData.Name = Path.GetFileName(path);

      return regressionData;
    }

    public override IRegressionProblemData LoadData(IDataDescriptor id) {
      var descriptor = (ResourceRegressionDataDescriptor)id;

      var instanceArchiveName = GetResourceName(FileName + @"\.zip");
      using (var instancesZipFile = new ZipArchive(GetType().Assembly.GetManifestResourceStream(instanceArchiveName), ZipArchiveMode.Read)) {
        var entry = instancesZipFile.GetEntry(descriptor.ResourceName);
        NumberFormatInfo numberFormat;
        DateTimeFormatInfo dateFormat;
        char separator;
        using (Stream stream = entry.Open()) {
          TableFileParser.DetermineFileFormat(stream, out numberFormat, out dateFormat, out separator);
        }

        TableFileParser csvFileParser = new TableFileParser();
        using (Stream stream = entry.Open()) {
          csvFileParser.Parse(stream, numberFormat, dateFormat, separator, true);
        }

        Dataset dataset = new Dataset(csvFileParser.VariableNames, csvFileParser.Values);
        if (!descriptor.CheckVariableNames(csvFileParser.VariableNames)) {
          throw new ArgumentException("Parsed file contains variables which are not in the descriptor.");
        }

        return descriptor.GenerateRegressionData(dataset);
      }
    }

    protected void OnExecuteActionActivated(Object sender, System.EventArgs e)
    {
        String connectionString ="Server=localhost;Database=dbprueba;User Id=dbprueba;Password=1234";
        NpgsqlCommand selectCommand = dbConnection.CreateCommand ();
        selectCommand.CommandText = "select * from categoria";
        NpgsqlDataAdapter dbDataAdapter = new NpgsqlDataAdapter();
        new NpgsqlCommandBuilder(dbDataAdapter);

            dbDataAdapter.SelectCommand = selectCommand;

        DataSet dataset = new Dataset();
        dbDataAdapter.Fill (DataSet);
        //Console.WriteLine("Tables.Count={0}", dataSet.Tables.Count);

        foreach(DataTable dataTable in dataset.Tables)
            show (dataTable);

        DataRow dataRow = dataset.Tables[0].Rows[0];
        dataRow["Nombre"] = DateTime.Now.ToString();

        Console.WriteLine("Cambios");
        show (dataset.Tables[0]);

        dbDataAdapter.Update(dataset);
    }

    public override IClusteringProblemData ImportData(string path) {
      var csvFileParser = new TableFileParser();
      csvFileParser.Parse(path, csvFileParser.AreColumnNamesInFirstLine(path));

      Dataset dataset = new Dataset(csvFileParser.VariableNames, csvFileParser.Values);

      // turn of input variables that are constant in the training partition
      var allowedInputVars = new List<string>();
      var trainingIndizes = Enumerable.Range(0, (csvFileParser.Rows * 2) / 3);
      if (trainingIndizes.Count() >= 2) {
        foreach (var variableName in dataset.DoubleVariables) {
          if (dataset.GetDoubleValues(variableName, trainingIndizes).Range() > 0)
            allowedInputVars.Add(variableName);
        }
      } else {
        allowedInputVars.AddRange(dataset.DoubleVariables);
      }

      ClusteringProblemData clusteringData = new ClusteringProblemData(dataset, allowedInputVars);

      int trainingPartEnd = trainingIndizes.Last();
      clusteringData.TrainingPartition.Start = trainingIndizes.First();
      clusteringData.TrainingPartition.End = trainingPartEnd;
      clusteringData.TestPartition.Start = trainingPartEnd;
      clusteringData.TestPartition.End = csvFileParser.Rows;

      clusteringData.Name = Path.GetFileName(path);

      return clusteringData;
    }

        public PolhemusController(Boolean polhemusConnected)
        {
            lastDatasetForEachStation = new Dictionary<int, Dataset>();
            //for (int i = 1; i <= Constants.numberOfPlayers; i++)
            lastDatasetForEachStation[1] = new Dataset();
            lastDatasetForEachStation[2] = new Dataset();

            if (polhemusConnected == true)
            {
                try
                {
                    Factory.CreateInstance(Debugmode.NoDebug);

                    Factory.Instance.PollingDelay = 30;
                    Factory.Instance.OnPolhemusButtonDown += new PolhemusEvent(OnPolhemusButtonDown);
                    Factory.Instance.OnPolhemusButtonUp += new PolhemusEvent(OnPolhemusButtonUp);
                    Factory.Instance.OnPolhemusMove += new PolhemusEvent(OnPolhemusMove);
                    isConnected = true;

                    Console.WriteLine("done with polhemus setup");
                }
                catch (Exception e)
                {
                    Console.WriteLine("There is no Polhemus connection: " + e);
                    isConnected = false;
                }
                sharedPolhemusController = this;
            }
        }

 public void addPolhemusDataset(Dataset dataset)
 {
     polhemusDatasets.Add(dataset);
     if (polhemusDatasets.Count == 4)
     {
         setUpCalibration();
     }
 }

 /// <summary>
 ///
 /// </summary>
 /// <remarks></remarks>
 /// <seealso cref=""/>
 /// <param name="dataset"></param>
 public DatasetVersion(Dataset   dataset)
     : this()
 {
     this.Dataset = dataset;
     //if (this.Dataset.DataStructure is UnStructuredDataStructure)
     //{
     //}
 }