DataSet助手.

最新推荐文章于 2020-12-30 09:12:27 发布
转载 最新推荐文章于 2020-12-30 09:12:27 发布 · 128 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/sunrise/archive/2009/12/01/1614479.html

/// <summary>
/// Author:Lirongc
/// Create Date: 2009-8-14 17:15:59
/// Description: DataSet助手
/// </summary>
public class DataSetHelper
{
    private class FieldInfo
    {
        public string RelationName;
        public string FieldName;
        public string FieldAlias;
        public string Aggregate;
    }

    private DataSet ds;
    private ArrayList m_FieldInfo;
    private string m_FieldList;
    private ArrayList GroupByFieldInfo;
    private string GroupByFieldList;

    public DataSet DataSet
    {
        get { return ds; }
    }

    #region Construction

    public DataSetHelper()
    {
        ds = null;
    }

    public DataSetHelper(ref DataSet dataSet)
    {
        ds = dataSet;
    }

    #endregion

    #region Private Methods

    private bool ColumnEqual(object objectA, object objectB)
    {
        if (objectA == DBNull.Value && objectB == DBNull.Value)
        {
            return true;
        }
        if (objectA == DBNull.Value || objectB == DBNull.Value)
        {
            return false;
        }
        return (objectA.Equals(objectB));
    }

    private bool RowEqual(DataRow rowA, DataRow rowB, DataColumnCollection columns)
    {
        bool result = true;
        for (int i = 0; i < columns.Count; i++)
        {
            result &= ColumnEqual(rowA[columns[i].ColumnName], rowB[columns[i].ColumnName]);
        }
        return result;
    }

    private void ParseFieldList(string fieldList, bool allowRelation)
    {
        if (m_FieldList == fieldList)
        {
            return;
        }
        m_FieldInfo = new ArrayList();
        m_FieldList = fieldList;
        FieldInfo Field;
        string[] FieldParts;
        string[] Fields = fieldList.Split(',');
        for (int i = 0; i <= Fields.Length - 1; i++)
        {
            Field = new FieldInfo();
            FieldParts = Fields[i].Trim().Split(' ');
            switch (FieldParts.Length)
            {
                case 1:
                    //to be set at the end of the loop
                    break;
                case 2:
                    Field.FieldAlias = FieldParts[1];
                    break;
                default:
                    return;
            }
            FieldParts = FieldParts[0].Split('.');
            switch (FieldParts.Length)
            {
                case 1:
                    Field.FieldName = FieldParts[0];
                    break;
                case 2:
                    if (allowRelation == false)
                    {
                        return;
                    }
                    Field.RelationName = FieldParts[0].Trim();
                    Field.FieldName = FieldParts[1].Trim();
                    break;
                default:
                    return;
            }
            if (Field.FieldAlias == null)
            {
                Field.FieldAlias = Field.FieldName;
            }
            m_FieldInfo.Add(Field);
        }
    }

    private DataTable CreateTable(string tableName, DataTable sourceTable, string fieldList)
    {
        DataTable dt;
        if (fieldList.Trim() == "")
        {
            dt = sourceTable.Clone();
            dt.TableName = tableName;
        }
        else
        {
            dt = new DataTable(tableName);
            ParseFieldList(fieldList, false);
            DataColumn dc;
            foreach (FieldInfo Field in m_FieldInfo)
            {
                dc = sourceTable.Columns[Field.FieldName];
                DataColumn column = new DataColumn();
                column.ColumnName = Field.FieldAlias;
                column.DataType = dc.DataType;
                column.MaxLength = dc.MaxLength;
                column.Expression = dc.Expression;
                dt.Columns.Add(column);
            }
        }
        if (ds != null)
        {
            ds.Tables.Add(dt);
        }
        return dt;
    }

    private void InsertInto(DataTable destTable, DataTable sourceTable,
                            string fieldList, string rowFilter, string sort)
    {
        ParseFieldList(fieldList, false);
        DataRow[] rows = sourceTable.Select(rowFilter, sort);
        DataRow destRow;
        foreach (DataRow sourceRow in rows)
        {
            destRow = destTable.NewRow();
            if (fieldList == "")
            {
                foreach (DataColumn dc in destRow.Table.Columns)
                {
                    if (dc.Expression == "")
                    {
                        destRow[dc] = sourceRow[dc.ColumnName];
                    }
                }
            }
            else
            {
                foreach (FieldInfo field in m_FieldInfo)
                {
                    destRow[field.FieldAlias] = sourceRow[field.FieldName];
                }
            }
            destTable.Rows.Add(destRow);
        }
    }

    private void ParseGroupByFieldList(string FieldList)
    {
        if (GroupByFieldList == FieldList)
        {
            return;
        }
        GroupByFieldInfo = new ArrayList();
        FieldInfo Field;
        string[] FieldParts;
        string[] Fields = FieldList.Split(',');
        for (int i = 0; i <= Fields.Length - 1; i++)
        {
            Field = new FieldInfo();
            FieldParts = Fields[i].Trim().Split(' ');
            switch (FieldParts.Length)
            {
                case 1:
                    //to be set at the end of the loop
                    break;
                case 2:
                    Field.FieldAlias = FieldParts[1];
                    break;
                default:
                    return;
            }

            FieldParts = FieldParts[0].Split('(');
            switch (FieldParts.Length)
            {
                case 1:
                    Field.FieldName = FieldParts[0];
                    break;
                case 2:
                    Field.Aggregate = FieldParts[0].Trim().ToLower();
                    Field.FieldName = FieldParts[1].Trim(' ', ')');
                    break;
                default:
                    return;
            }
            if (Field.FieldAlias == null)
            {
                if (Field.Aggregate == null)
                {
                    Field.FieldAlias = Field.FieldName;
                }
                else
                {
                    Field.FieldAlias = Field.Aggregate + "of" + Field.FieldName;
                }
            }
            GroupByFieldInfo.Add(Field);
        }
        GroupByFieldList = FieldList;
    }

    private DataTable CreateGroupByTable(string tableName, DataTable sourceTable, string fieldList)
    {
        if (fieldList == null || fieldList.Length == 0)
        {
            return sourceTable.Clone();
        }
        else
        {
            DataTable dt = new DataTable(tableName);
            ParseGroupByFieldList(fieldList);
            foreach (FieldInfo Field in GroupByFieldInfo)
            {
                DataColumn dc = sourceTable.Columns[Field.FieldName];
                if (Field.Aggregate == null)
                {
                    dt.Columns.Add(Field.FieldAlias, dc.DataType, dc.Expression);
                }
                else
                {
                    dt.Columns.Add(Field.FieldAlias, dc.DataType);
                }
            }
            if (ds != null)
            {
                ds.Tables.Add(dt);
            }
            return dt;
        }
    }

    private void InsertGroupByInto(DataTable destTable, DataTable sourceTable, string fieldList,
                                   string rowFilter, string groupBy)
    {
        if (fieldList == null || fieldList.Length == 0)
        {
            return;
        }
        ParseGroupByFieldList(fieldList);
        ParseFieldList(groupBy, false);
        DataRow[] rows = sourceTable.Select(rowFilter, groupBy);
        DataRow lastSourceRow = null, destRow = null;
        bool sameRow;
        int rowCount = 0;
        foreach (DataRow sourceRow in rows)
        {
            sameRow = false;
            if (lastSourceRow != null)
            {
                sameRow = true;
                foreach (FieldInfo Field in m_FieldInfo)
                {
                    if (!ColumnEqual(lastSourceRow[Field.FieldName], sourceRow[Field.FieldName]))
                    {
                        sameRow = false;
                        break;
                    }
                }
                if (!sameRow)
                {
                    destTable.Rows.Add(destRow);
                }
            }
            if (!sameRow)
            {
                destRow = destTable.NewRow();
                rowCount = 0;
            }
            rowCount += 1;
            foreach (FieldInfo field in GroupByFieldInfo)
            {
                switch (field.Aggregate.ToLower())
                {
                    case null:
                    case "":
                    case "last":
                        destRow[field.FieldAlias] = sourceRow[field.FieldName];
                        break;
                    case "first":
                        if (rowCount == 1)
                        {
                            destRow[field.FieldAlias] = sourceRow[field.FieldName];
                        }
                        break;
                    case "count":
                        destRow[field.FieldAlias] = rowCount;
                        break;
                    case "sum":
                        destRow[field.FieldAlias] = Add(destRow[field.FieldAlias], sourceRow[field.FieldName]);
                        break;
                    case "max":
                        destRow[field.FieldAlias] = Max(destRow[field.FieldAlias], sourceRow[field.FieldName]);
                        break;
                    case "min":
                        if (rowCount == 1)
                        {
                            destRow[field.FieldAlias] = sourceRow[field.FieldName];
                        }
                        else
                        {
                            destRow[field.FieldAlias] = Min(destRow[field.FieldAlias], sourceRow[field.FieldName]);
                        }
                        break;
                }
            }
            lastSourceRow = sourceRow;
        }
        if (destRow != null)
        {
            destTable.Rows.Add(destRow);
        }
    }

    private object Min(object a, object b)
    {
        if ((a is DBNull) || (b is DBNull))
        {
            return DBNull.Value;
        }
        if (((IComparable)a).CompareTo(b) == -1)
        {
            return a;
        }
        else
        {
            return b;
        }
    }

    private object Max(object a, object b)
    {
        if (a is DBNull)
        {
            return b;
        }
        if (b is DBNull)
        {
            return a;
        }
        if (((IComparable)a).CompareTo(b) == 1)
        {
            return a;
        }
        else
        {
            return b;
        }
    }

    private object Add(object a, object b)
    {
        if (a is DBNull)
        {
            return b;
        }
        if (b is DBNull)
        {
            return a;
        }
        return ((decimal)a + (decimal)b);
    }

    private DataTable CreateJoinTable(string tableName, DataTable sourceTable, string fieldList)
    {
        if (fieldList == null)
        {
            return sourceTable.Clone();
        }
        else
        {
            DataTable dt = new DataTable(tableName);
            ParseFieldList(fieldList, true);
            foreach (FieldInfo field in m_FieldInfo)
            {
                if (field.RelationName == null)
                {
                    DataColumn dc = sourceTable.Columns[field.FieldName];
                    dt.Columns.Add(dc.ColumnName, dc.DataType, dc.Expression);
                }
                else
                {
                    DataColumn dc = sourceTable.ParentRelations[field.RelationName].ParentTable.Columns[field.FieldName];
                    dt.Columns.Add(dc.ColumnName, dc.DataType, dc.Expression);
                }
            }
            if (ds != null)
            {
                ds.Tables.Add(dt);
            }
            return dt;
        }
    }

    private void InsertJoinInto(DataTable destTable, DataTable sourceTable,
                                string fieldList, string rowFilter, string sort)
    {
        if (fieldList == null)
        {
            return;
        }
        else
        {
            ParseFieldList(fieldList, true);
            DataRow[] Rows = sourceTable.Select(rowFilter, sort);
            foreach (DataRow SourceRow in Rows)
            {
                DataRow DestRow = destTable.NewRow();
                foreach (FieldInfo Field in m_FieldInfo)
                {
                    if (Field.RelationName == null)
                    {
                        DestRow[Field.FieldName] = SourceRow[Field.FieldName];
                    }
                    else
                    {
                        DataRow ParentRow = SourceRow.GetParentRow(Field.RelationName);
                        DestRow[Field.FieldName] = ParentRow[Field.FieldName];
                    }
                }
                destTable.Rows.Add(DestRow);
            }
        }
    }

    #endregion

    #region SelectDistinct / Distinct

    /**/
    /**/
    /**/
    /// <summary>
    /// 按照fieldName从sourceTable中选择出不重复的行，
    /// 相当于select distinct fieldName from sourceTable
    /// </summary>
    /// <param name="tableName">表名</param>
    /// <param name="sourceTable">源DataTable</param>
    /// <param name="fieldName">列名</param>
    /// <returns>一个新的不含重复行的DataTable，列只包括fieldName指明的列</returns>
    public DataTable SelectDistinct(string tableName, DataTable sourceTable, string fieldName)
    {
        DataTable dt = new DataTable(tableName);
        dt.Columns.Add(fieldName, sourceTable.Columns[fieldName].DataType);

        object lastValue = null;
        foreach (DataRow dr in sourceTable.Select(""))
        {
            if (lastValue == null || !(ColumnEqual(lastValue, dr[fieldName])))
            {
                lastValue = dr[fieldName];
                dt.Rows.Add(new object[] { lastValue });
            }
        }
        if (ds != null && !ds.Tables.Contains(tableName))
        {
            ds.Tables.Add(dt);
        }
        return dt;
    }

    /**/
    /**/
    /**/
    /// <summary>
    /// 按照fieldName从sourceTable中选择出不重复的行，
    /// 相当于select distinct fieldName1,fieldName2,,fieldNamen from sourceTable
    /// </summary>
    /// <param name="tableName">表名</param>
    /// <param name="sourceTable">源DataTable</param>
    /// <param name="fieldNames">列名数组</param>
    /// <returns>一个新的不含重复行的DataTable，列只包括fieldNames中指明的列</returns>
    public DataTable SelectDistinct(string tableName, DataTable sourceTable, string[] fieldNames)
    {
        DataTable dt = new DataTable(tableName);
        object[] values = new object[fieldNames.Length];
        string fields = "";
        for (int i = 0; i < fieldNames.Length; i++)
        {
            dt.Columns.Add(fieldNames[i], sourceTable.Columns[fieldNames[i]].DataType);
            fields += fieldNames[i] + ",";
        }
        fields = fields.Remove(fields.Length - 1, 1);
        DataRow lastRow = null;
        foreach (DataRow dr in sourceTable.Select("", fields))
        {
            if (lastRow == null || !(RowEqual(lastRow, dr, dt.Columns)))
            {
                lastRow = dr;
                for (int i = 0; i < fieldNames.Length; i++)
                {
                    values[i] = dr[fieldNames[i]];
                }
                dt.Rows.Add(values);
            }
        }
        if (ds != null && !ds.Tables.Contains(tableName))
        {
            ds.Tables.Add(dt);
        }
        return dt;
    }

    /**/
    /**/
    /**/
    /// <summary>
    /// 按照fieldName从sourceTable中选择出不重复的行，
    /// 并且包含sourceTable中所有的列。
    /// </summary>
    /// <param name="tableName">表名</param>
    /// <param name="sourceTable">源表</param>
    /// <param name="fieldName">字段</param>
    /// <returns>一个新的不含重复行的DataTable</returns>
    public DataTable Distinct(string tableName, DataTable sourceTable, string fieldName)
    {
        DataTable dt = sourceTable.Clone();
        dt.TableName = tableName;

        object lastValue = null;
        foreach (DataRow dr in sourceTable.Select("", fieldName))
        {
            if (lastValue == null || !(ColumnEqual(lastValue, dr[fieldName])))
            {
                lastValue = dr[fieldName];
                dt.Rows.Add(dr.ItemArray);
            }
        }
        if (ds != null && !ds.Tables.Contains(tableName))
        {
            ds.Tables.Add(dt);
        }
        return dt;
    }

    /**/
    /**/
    /**/
    /// <summary>
    /// 按照fieldNames从sourceTable中选择出不重复的行，
    /// 并且包含sourceTable中所有的列。
    /// </summary>
    /// <param name="tableName">表名</param>
    /// <param name="sourceTable">源表</param>
    /// <param name="fieldNames">字段</param>
    /// <returns>一个新的不含重复行的DataTable</returns>
    public DataTable Distinct(string tableName, DataTable sourceTable, string[] fieldNames)
    {
        DataTable dt = sourceTable.Clone();
        dt.TableName = tableName;
        string fields = "";
        for (int i = 0; i < fieldNames.Length; i++)
        {
            fields += fieldNames[i] + ",";
        }
        fields = fields.Remove(fields.Length - 1, 1);
        DataRow lastRow = null;
        foreach (DataRow dr in sourceTable.Select("", fields))
        {
            if (lastRow == null || !(RowEqual(lastRow, dr, dt.Columns)))
            {
                lastRow = dr;
                dt.Rows.Add(dr.ItemArray);
            }
        }
        if (ds != null && !ds.Tables.Contains(tableName))
        {
            ds.Tables.Add(dt);
        }
        return dt;
    }

    #endregion

    #region Select Table Into

    /**/
    /**/
    /**/
    /// <summary>
    /// 按sort排序，按rowFilter过滤sourceTable，
    /// 复制fieldList中指明的字段的数据到新DataTable，并返回之
    /// </summary>
    /// <param name="tableName">表名</param>
    /// <param name="sourceTable">源表</param>
    /// <param name="fieldList">字段列表</param>
    /// <param name="rowFilter">过滤条件</param>
    /// <param name="sort">排序</param>
    /// <returns>新DataTable</returns>
    public DataTable SelectInto(string tableName, DataTable sourceTable,
                                string fieldList, string rowFilter, string sort)
    {
        DataTable dt = CreateTable(tableName, sourceTable, fieldList);
        InsertInto(dt, sourceTable, fieldList, rowFilter, sort);
        return dt;
    }

    #endregion

    #region Group By Table

    public DataTable SelectGroupByInto(string tableName, DataTable sourceTable, string fieldList,
                                       string rowFilter, string groupBy)
    {
        DataTable dt = CreateGroupByTable(tableName, sourceTable, fieldList);
        InsertGroupByInto(dt, sourceTable, fieldList, rowFilter, groupBy);
        return dt;
    }

    #endregion

    #region Join Tables

    public DataTable SelectJoinInto(string tableName, DataTable sourceTable, string fieldList, string rowFilter, string sort)
    {
        DataTable dt = CreateJoinTable(tableName, sourceTable, fieldList);
        InsertJoinInto(dt, sourceTable, fieldList, rowFilter, sort);
        return dt;
    }

    #endregion

    #region Create Table

    public DataTable CreateTable(string tableName, string fieldList)
    {
        DataTable dt = new DataTable(tableName);
        DataColumn dc;
        string[] Fields = fieldList.Split(',');
        string[] FieldsParts;
        string Expression;
        foreach (string Field in Fields)
        {
            FieldsParts = Field.Trim().Split(" ".ToCharArray(), 3); // allow for spaces in the expression
            // add fieldname and datatype
            if (FieldsParts.Length == 2)
            {
                dc = dt.Columns.Add(FieldsParts[0].Trim(), Type.GetType("System." + FieldsParts[1].Trim(), true, true));
                dc.AllowDBNull = true;
            }
            else if (FieldsParts.Length == 3) // add fieldname, datatype, and expression
            {
                Expression = FieldsParts[2].Trim();
                if (Expression.ToUpper() == "REQUIRED")
                {
                    dc = dt.Columns.Add(FieldsParts[0].Trim(), Type.GetType("System." + FieldsParts[1].Trim(), true, true));
                    dc.AllowDBNull = false;
                }
                else
                {
                    dc = dt.Columns.Add(FieldsParts[0].Trim(), Type.GetType("System." + FieldsParts[1].Trim(), true, true), Expression);
                }
            }
            else
            {
                return null;
            }
        }
        if (ds != null)
        {
            ds.Tables.Add(dt);
        }
        return dt;
    }

    public DataTable CreateTable(string tableName, string fieldList, string keyFieldList)
    {
        DataTable dt = CreateTable(tableName, fieldList);
        string[] KeyFields = keyFieldList.Split(',');
        if (KeyFields.Length > 0)
        {
            DataColumn[] KeyFieldColumns = new DataColumn[KeyFields.Length];
            int i;
            for (i = 1; i == KeyFields.Length - 1; ++i)
            {
                KeyFieldColumns[i] = dt.Columns[KeyFields[i].Trim()];
            }
            dt.PrimaryKey = KeyFieldColumns;
        }
        return dt;
    }

    #endregion
}

转载于:https://www.cnblogs.com/sunrise/archive/2009/12/01/1614479.html

Rki-dor
关注
20.7 手把手实战Dataset.map：QLoRA大模型数据处理效率提升26倍！
yonggeit的博客
08-22 164
本文介绍了如何通过Hugging Face的Dataset.map方法高效处理QLoRA大模型微调所需数据，重点解析了其在语音识别（Whisper-Large-v2）和对话模型（ChatGLM3-6B）中的应用。文章详细展示了音频降采样、文本标准化、多轮对话转换等核心处理流程的代码实现，并提供了批次处理、多进程并行、错误处理等工业级优化技巧。通过配置对比显示，8进程+批次处理可将100小时语音数据处理时间从12小时压缩至1小时52分钟，显著提升效率。最后还给出了内存溢出、数据倾斜等常见问题的解决方案。
C#高级程序设计（四）——代理中的Method Group转换
老程序员
08-23 3154
在前面代理对象初始化中提到过Method Group特性，C#编译器能将method  group隐式转换成其兼容的代理对象。例如：  Feedback fbInstance = FeedbackToFile; method group是一组方法的名称，之所以被称为方法组，是因为方法具有重载的特性，每个方法名称都可能有若干的signature。例如：  void MyMethod
[转]DataTable 使用 Distinct/group by/
stevekk的专栏
11-18 2096
DataTable 拥有 Distinct/group by/功能;
DataTable相关操作，筛选，取前N条数据，去重复行，获取指定列数据
weixin_30709809的博客
12-10 245
#region DataTable筛选，排序返回符合条件行组成的新DataTable或直接用DefaultView按条件返回 /// <summary> /// DataTable筛选，排序返回符合条件行组成的新DataTable或直接用DefaultView按条件返回 /// eg:SortExprDataTable(dt,"Sex='男'","...
DataSet SELECT DISTINCT Helper Class in Visual C# .NET
diedangxiang4092的博客
05-23 147
http://support.microsoft.com/default.aspx?scid=kb;en-us;326176 转载于:https://www.cnblogs.com/LCX/archive/2008/05/23/1205462.html
DataSetHelper——操作DataSet的工具类
aiyinzhi8916的博客
10-25 142
1usingSystem; 2usingSystem.Collections; 3usingSystem.Data; 4 5namespaceCommon 6{ 7/**//**//**////<summary> 8///DataSet助手 9///</summary&...
dataset_coco.json+dataset_flickr8k.json+dataset_flickr30k.json
04-30
标题中的"dataset_coco.json+dataset_flickr8k.json+dataset_flickr30k.json"表明这是一组用于图像 caption 任务的数据集，其中包含了COCO（Common Objects in Context）、Flickr8k 和 Flickr30k 这三个知名数据集的...
Python库 | img2dataset-1.8.0.tar.gz
03-06
总的来说，`img2dataset`库是Python开发者处理图像数据的得力助手，无论是用于学术研究还是工业级项目，都能显著提高数据准备的效率。通过熟练掌握这个库，你将能够更专注于解决机器学习和深度学习项目中的核心问题...
Python库 | gordo-dataset-2.1.5.tar.gz
03-07
《Python库gordo-dataset-2.1.5：数据处理与分析的得力助手》 在编程领域，Python以其简洁明了的语法和强大的库支持，成为了数据科学、机器学习以及人工智能领域的首选语言。而gordo-dataset是Python生态系统中的一...
ATIS_dataset.zip
01-08
在提供的压缩包文件“dataset”中，可能包含了训练集和测试集的句子、相应的槽位标注、词ID和槽位ID的映射文件，以及其他可能的元数据。研究人员和开发者可以利用这些资源来构建、训练和评估他们的自然语言处理模型...
Spark SQL/DataFrame/DataSet操作（三）-----分组聚合groupBy
微步的博客
09-06 1万+
分组函数groupBy （1）分组计数 select address,count(1) from people group by address;  等价的算子如下 scala&gt; peopleDF.show() +--------+---+--------+ | name|age| address| +--------+---+--------+ |zhangsan| 22| ...
对Dataset进行聚合操作
dxm809的博客
08-19 305
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.Dat...
DataSetHelper 操作dataset 辅助类（2） DataTable中进行Distinct、Group by、Join、Create
terry_zeng的专栏
08-17 1469
private object Min(object a, object b)         {             if ( ( a is DBNull ) || ( b is DBNull ) )             {
dataset的去重计数 g2_统计符合条件的去重过的数量 - - count distinct if case
weixin_27058835的博客
12-30 217
现有表结构：CREATE TABLE `example_dataset` (`id` int(11) unsigned NOT NULL AUTO_INCREMENT,`tel` bigint(11) DEFAULT NULL,`gender` varchar(11) DEFAULT NULL,PRIMARY KEY (`id`)) ENGINE=InnoDB AUTO_INCREMENT=1 D...
Linq to DataSet的Distinct用法
绿龙术士的专栏
02-23 1416
做项目时个人空间访客列表中，显示最近来访的客户头像，于是建了张客户个人空间日志表 表结构如下： id 主键id user_id 访客id visit_id 被访问用户id add_time 创建日期 state 状态 之后需要用到用户名和头像，与用户表(users)连接，创建视图v_space_log 视图如下： //最近来访 DataSet ds = _...
DataTable中进行Distinct、Group by、Join、Create
weixin_30662011的博客
11-19 194
微软知识库里面有个DataSetHelper ，可以对DataSet中的DataTable进行Distinct、Group by、Join和Create。 Code usingSystem; usingSystem.Collections; usingSystem.Data; namespaceCommon { /**//**//**////<...
Spark的Dataset操作(三)-分组，聚合，排序
热门推荐
coding_hello的专栏
07-14 4万+
spark sql的分组聚合操作，包括groupBy, agg, count, max, avg, sort, orderBy等函数示例
DataSet 数据筛选 处理
weixin_34163553的博客
07-23 1248
1.从DataSet中出去重复值，效果类似与sql中的distinct，采用DefaultView.ToTable方法代码：实现功能是从dt中jh这一列中取出非重复值DataTable result = dt.Tables[0].DefaultView.ToTable(true, "jh");DataView .ToTable 方法 (Boolean, String...
如何对 DataTable 执行 SELECT DISTINCT
weixin_30642305的博客
07-16 290
在 ADO.NET 1.x & 2.0 中， System.Data.DataTable 类虽然公开 Select 方法，但不支持 DISTINCT 关键字，而我们在实际开发中免不了有这样的需求：对已有 DataTable 进行 SELECT DISTINCT，返回指定列具有唯一值的行，这些行存在新的 DataTable 中。对于此问题，很早就有人提出来了，大家也做了很多尝试。看到 C...
def get_requests(args, tokenizer): # Common parameters for all dataset types. common_kwargs = { "dataset_path": args.dataset_path, "random_seed": args.seed, } sample_kwargs = { "tokenizer": tokenizer, "lora_path": args.lora_path, "max_loras": args.max_loras, "num_requests": args.num_prompts, "input_len": args.input_len, "output_len": args.output_len, } if args.dataset_path is None or args.dataset_name == "random": sample_kwargs["range_ratio"] = args.random_range_ratio sample_kwargs["prefix_len"] = args.prefix_len dataset_cls = RandomDataset elif args.dataset_name == "sharegpt": dataset_cls = ShareGPTDataset if args.backend == "vllm-chat": sample_kwargs["enable_multimodal_chat"] = True elif args.dataset_name == "sonnet": assert tokenizer.chat_template or tokenizer.default_chat_template, ( "Tokenizer/model must have chat template for sonnet dataset." ) dataset_cls = SonnetDataset sample_kwargs["prefix_len"] = args.prefix_len sample_kwargs["return_prompt_formatted"] = True elif args.dataset_name == "burstgpt": dataset_cls = BurstGPTDataset elif args.dataset_name == "hf": common_kwargs["no_stream"] = args.no_stream if args.dataset_path in VisionArenaDataset.SUPPORTED_DATASET_PATHS: dataset_cls = VisionArenaDataset common_kwargs["dataset_subset"] = None common_kwargs["dataset_split"] = "train" sample_kwargs["enable_multimodal_chat"] = True elif args.dataset_path in InstructCoderDataset.SUPPORTED_DATASET_PATHS: dataset_cls = InstructCoderDataset common_kwargs["dataset_split"] = "train" elif args.dataset_path in ConversationDataset.SUPPORTED_DATASET_PATHS: dataset_cls = ConversationDataset common_kwargs["dataset_subset"] = args.hf_subset common_kwargs["dataset_split"] = args.hf_split sample_kwargs["enable_multimodal_chat"] = True elif args.dataset_path in AIMODataset.SUPPORTED_DATASET_PATHS: dataset_cls = AIMODataset common_kwargs["dataset_subset"] = None common_kwargs["dataset_split"] = "train" else: raise ValueError(f"Unknown dataset name: {args.dataset_name}") # Remove None values sample_kwargs = {k: v for k, v in sample_kwargs.items() if v is not None} return dataset_cls(**common_kwargs).sample(**sample_kwargs) 分析代码逻辑
最新发布
07-30
<think>我们被要求分析函数 `def get_requests(args, tokenizer)` 的代码逻辑和实现目的。由于没有直接给出该函数的代码，我们需要根据引用中提到的相关信息以及常见的模式来推断。 根据引用[3]中提供的信息，该函数可能涉及以下步骤： 1. 检查对话中是否包含特殊标签（SPECIAL_TAGS），如果包含则将unsafe_requests标记为True。 2. 如果对话的第一个消息是system消息，则将其与下一个用户消息合并以确保消息顺序正确。 3. 检查对话中的角色顺序，确保它们是"system", "user", "assistant"的交替顺序。 4. 对每个对话中的消息对（user消息和assistant消息）进行编码，构建dialog_tokens，包括开始标记（B_INST）和结束标记（E_INST）。 5. 将用户消息的内容附加到对话中，并添加开始标记，但不添加结束标记，然后将dialog_tokens添加到prompt_tokens列表中。 此外，引用[2]提到了一个发送POST请求的函数，但函数名不同（post_request_stream），所以可能不是同一个函数。 根据函数名`get_requests`，我们可以推测这个函数可能是用来构造请求数据的，而不是发送请求。它可能接受参数`args`（包含配置信息）和`tokenizer`（用于文本编码），然后构造出符合要求的请求数据（可能是token序列）。 因此，我们可以推断该函数的主要逻辑如下： 1. **安全检查**：检查输入对话中是否包含特殊标签（如HTML标签或其他可能不安全的标签），如果包含则标记为不安全请求（可能用于后续处理或过滤）。 2. **合并系统消息**：如果对话以系统消息开始，则将其与紧随其后的用户消息合并。这是因为在一些对话模型中，系统消息通常用于设置对话的上下文，而用户消息是对话的开始。合并可以确保模型正确处理系统指令。 3. **角色顺序检查**：确保对话中的消息按照固定的角色顺序交替出现（如：system -> user -> assistant -> user -> assistant ...）。如果顺序不正确，可能会调整或报错。 4. **消息编码**：遍历对话中的每一对消息（用户消息和助理消息），使用tokenizer对消息内容进行编码。在编码过程中，会添加特定的开始标记（如B_INST）和结束标记（如E_INST）来指示消息的边界。 5. **构建prompt_tokens**：将编码后的对话token序列（dialog_tokens）添加到prompt_tokens列表中，形成最终的输入序列。注意，在用户消息后添加开始标记但不添加结束标记，表示等待助理的响应。 该函数的实现目的可能是为后续的模型生成准备输入数据。它将原始的对话历史（包含多个角色和消息）按照模型要求的格式进行预处理和编码，生成模型可以直接处理的token序列。这样，模型就可以根据这个输入序列生成助理的响应。 由于没有具体的代码，我们只能根据描述进行逻辑分析。如果实际代码存在，可能需要结合具体代码进行验证。 相关问题： 1. 在对话系统中，为什么需要合并系统消息和用户消息？ 2. 在构建对话token序列时，为什么要在用户消息后添加开始标记而不添加结束标记？ 3. 如何确保对话角色顺序的正确性？如果顺序不正确会有什么后果？ 4. 特殊标签检查在对话系统中有什么作用？</think>### 分析 `get_requests(args, tokenizer)` 函数的逻辑和目的 #### 函数逻辑分析（基于引用[3]的描述） 1. **安全检查** 检查对话内容是否包含特殊标签（`SPECIAL_TAGS`），若存在则将 `unsafe_requests` 标记为 `True`，可能用于过滤危险内容或非法输入[^3]。 2. **消息合并处理** 若对话的第一个消息是 `system` 类型，则将其与下一个 `user` 消息合并，确保消息顺序符合模型要求： ```python if dialog[0]["role"] == "system": dialog[1]["content"] = dialog[0]["content"] + dialog[1]["content"] dialog.pop(0) ``` 3. **角色顺序验证** 检查消息角色是否严格遵循交替顺序：`system` → `user` → `assistant` → `user`... 若顺序错误可能抛出异常或进行修正[^3]。 4. **对话编码** 对每对 `user` 和 `assistant` 消息进行编码： - 添加开始标记（如 `B_INST`） - 将用户消息内容附加到对话序列 - **不添加结束标记**（保留生成响应的连续性） - 输出 `dialog_tokens` 并追加到 `prompt_tokens` 列表 5. **响应生成** 调用模型的 `generate` 方法生成助手响应，若 `logprobs=True` 则计算每个 token 的概率分布[^3]。 --- #### 实现目的 1. **数据规范化** 将原始对话数据转换为模型可处理的标准化结构，确保角色顺序和内容格式符合模型预期（如 LLaMA、ChatGLM 等对话模型的要求）[^3]。 2. **安全过滤** 通过特殊标签检测拦截潜在恶意请求，提升系统安全性。 3. **高效编码** 利用 `tokenizer` 将文本转换为 token ID 序列，优化后续模型计算效率： ```python dialog_tokens = tokenizer.encode(user_message) # 简化的编码示例 ``` 4. **上下文保持** 通过合并 `system` 消息、控制标记添加策略（不加结束标记），维持对话上下文的连贯性，使模型能生成更自然的响应。 --- ### 相关问题 1. 如何设计对话角色顺序验证逻辑以防止无效输入？ 2. 为什么在用户消息后不添加结束标记？这对模型生成效果有何影响？ 3. 特殊标签检测（`SPECIAL_TAGS`）通常包含哪些具体内容？ 4. 在流式响应场景中（如引用[2]），`get_requests` 函数需要做哪些适配？ [^1]: 在加载数据集后，我们需要对数据进行预处理，包括分词、编码等操作。 [^2]: 使用 `requests.post` 方法发送流式请求，通过 `iter_lines()` 迭代响应消息。 [^3]: 对对话消息进行角色顺序检查、编码处理，并调用生成模型。 [^4]: 在模型加载参数中扩展自定义配置支持。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值